Gtk418 = Gtk418 or {}
Gtk418.__version_no__ = "Gtk418"
Gtk418.__module_name__ = "gtk4"

----  [Gtk interfaces] Start ... 
---------------------  GtkAccessible
Gtk418.GtkAccessible = {
  class = "GtkAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_accessible_parent       = {"GtkAccessible*", {"GtkAccessible*"}, {"self"} }, 
    get_at_context              = {"GtkATContext*" , {"GtkAccessible*"}, {"self"} }, 
    get_bounds                  = {"gboolean"      , {"GtkAccessible*", "int*", "int*", "int*", "int*"}, {"self", "x", "y", "width", "height"} }, 
    get_first_accessible_child  = {"GtkAccessible*", {"GtkAccessible*"}, {"self"} }, 
    get_next_accessible_sibling = {"GtkAccessible*", {"GtkAccessible*"}, {"self"} }, 
    get_platform_state          = {"gboolean"      , {"GtkAccessible*", "GtkAccessiblePlatformState"}, {"self", "state"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accessible-role"] = {__type__="GtkAccessibleRole" ,__default__ = "GTK_ACCESSIBLE_ROLE_NONE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkAccessibleRange
Gtk418.GtkAccessibleRange = {
  class = "GtkAccessibleRange", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    set_current_value = {"gboolean", {"GtkAccessibleRange*", "double"}, {"self", "value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkAccessibleText
Gtk418.GtkAccessibleText = {
  class = "GtkAccessibleText", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_attributes         = {"gboolean"    , {"GtkAccessibleText*", "unsigned int", "gsize*", "GtkAccessibleTextRange**", "char***", "char***"}, {"self", "offset", "n_ranges", "ranges", "attribute_names", "attribute_values"} }, 
    get_caret_position     = {"unsigned int", {"GtkAccessibleText*"}, {"self"} }, 
    get_contents           = {"GBytes*"     , {"GtkAccessibleText*", "unsigned int", "unsigned int"}, {"self", "start", "end"} }, 
    get_contents_at        = {"GBytes*"     , {"GtkAccessibleText*", "unsigned int", "GtkAccessibleTextGranularity", "unsigned int*", "unsigned int*"}, {"self", "offset", "granularity", "start", "end"} }, 
    get_default_attributes = {"void"        , {"GtkAccessibleText*", "char***", "char***"}, {"self", "attribute_names", "attribute_values"} }, 
    get_extents            = {"gboolean"    , {"GtkAccessibleText*", "unsigned int", "unsigned int", "graphene_rect_t*"}, {"self", "start", "end", "extents"} }, 
    get_offset             = {"gboolean"    , {"GtkAccessibleText*", "const graphene_point_t*", "unsigned int*"}, {"self", "point", "offset"} }, 
    get_selection          = {"gboolean"    , {"GtkAccessibleText*", "gsize*", "GtkAccessibleTextRange**"}, {"self", "n_ranges", "ranges"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkActionable
Gtk418.GtkActionable = {
  class = "GtkActionable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_action_name         = {"const char*", {"GtkActionable*"}, {"actionable"} }, 
    get_action_target_value = {"GVariant*"  , {"GtkActionable*"}, {"actionable"} }, 
    set_action_name         = {"void"       , {"GtkActionable*", "const char*"}, {"actionable", "action_name"} }, 
    set_action_target_value = {"void"       , {"GtkActionable*", "GVariant*"}, {"actionable", "target_value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["action-name"]   = {__type__="gchar*"    ,__default__ = "NULL" , __gencode__ = {"gtk_actionable_set_action_name((GtkActionable*)({* id *}), (const char*)({* property.value *}))"} },
    ["action-target"] = {__type__="GVariant*" ,__default__ = "NULL" , __gencode__ = {"gtk_actionable_set_action_target((GtkActionable*)({* id *}), (const char*)({* property.value *}), (void)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkAppChooser
Gtk418.GtkAppChooser = {
  class = "GtkAppChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["content-type"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkBuildable
Gtk418.GtkBuildable = {
  class = "GtkBuildable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_child              = {"void"       , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const char*"}, {"buildable", "builder", "child", "type"} }, 
    construct_child        = {"GObject*"   , {"GtkBuildable*", "GtkBuilder*", "const char*"}, {"buildable", "builder", "name"} }, 
    custom_finished        = {"void"       , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const char*", "gpointer"}, {"buildable", "builder", "child", "tagname", "data"} }, 
    custom_tag_end         = {"void"       , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const char*", "gpointer"}, {"buildable", "builder", "child", "tagname", "data"} }, 
    custom_tag_start       = {"gboolean"   , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const char*", "GtkBuildableParser*", "gpointer*"}, {"buildable", "builder", "child", "tagname", "parser", "data"} }, 
    get_id                 = {"const char*", {"GtkBuildable*"}, {"buildable"} }, 
    get_internal_child     = {"GObject*"   , {"GtkBuildable*", "GtkBuilder*", "const char*"}, {"buildable", "builder", "childname"} }, 
    parser_finished        = {"void"       , {"GtkBuildable*", "GtkBuilder*"}, {"buildable", "builder"} }, 
    set_buildable_property = {"void"       , {"GtkBuildable*", "GtkBuilder*", "const char*", "const GValue*"}, {"buildable", "builder", "name", "value"} }, 
    set_id                 = {"void"       , {"GtkBuildable*", "const char*"}, {"buildable", "id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkBuilderScope
Gtk418.GtkBuilderScope = {
  class = "GtkBuilderScope", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_closure         = {"GClosure*", {"GtkBuilderScope*", "GtkBuilder*", "const char*", "GtkBuilderClosureFlags", "GObject*"}, {"self", "builder", "function_name", "flags", "object"} }, 
    get_type_from_function = {"GType"    , {"GtkBuilderScope*", "GtkBuilder*", "const char*"}, {"self", "builder", "function_name"} }, 
    get_type_from_name     = {"GType"    , {"GtkBuilderScope*", "GtkBuilder*", "const char*"}, {"self", "builder", "type_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkCellEditable
Gtk418.GtkCellEditable = {
  class = "GtkCellEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    editing_done  = {"void", {"GtkCellEditable*"}, {"cell_editable"} }, 
    remove_widget = {"void", {"GtkCellEditable*"}, {"cell_editable"} }, 
    start_editing = {"void", {"GtkCellEditable*", "GdkEvent*"}, {"cell_editable", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['editing-done']  = {ret_type = "void", params = {type = {"GtkCellEditable*"}, name ={"celleditable"}} }, 
    ['remove-widget'] = {ret_type = "void", params = {type = {"GtkCellEditable*"}, name ={"celleditable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["editing-canceled"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkCellLayout
Gtk418.GtkCellLayout = {
  class = "GtkCellLayout", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_attribute      = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "const char*", "int"}, {"cell_layout", "cell", "attribute", "column"} }, 
    clear              = {"void"        , {"GtkCellLayout*"}, {"cell_layout"} }, 
    clear_attributes   = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*"}, {"cell_layout", "cell"} }, 
    get_area           = {"GtkCellArea*", {"GtkCellLayout*"}, {"cell_layout"} }, 
    get_cells          = {"GList*"      , {"GtkCellLayout*"}, {"cell_layout"} }, 
    pack_end           = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "gboolean"}, {"cell_layout", "cell", "expand"} }, 
    pack_start         = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "gboolean"}, {"cell_layout", "cell", "expand"} }, 
    reorder            = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "int"}, {"cell_layout", "cell", "position"} }, 
    set_cell_data_func = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "GtkCellLayoutDataFunc", "gpointer", "GDestroyNotify"}, {"cell_layout", "cell", "func", "func_data", "destroy"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkColorChooser
Gtk418.GtkColorChooser = {
  class = "GtkColorChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_palette     = {"void", {"GtkColorChooser*", "GtkOrientation", "int", "int", "GdkRGBA*"}, {"chooser", "orientation", "colors_per_line", "n_colors", "colors"} }, 
    color_activated = {"void", {"GtkColorChooser*", "const GdkRGBA*"}, {"chooser", "color"} }, 
    get_rgba        = {"void", {"GtkColorChooser*", "GdkRGBA*"}, {"chooser", "color"} }, 
    set_rgba        = {"void", {"GtkColorChooser*", "const GdkRGBA*"}, {"chooser", "color"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['color-activated'] = {ret_type = "void", params = {type = {"GtkColorChooser*", "GdkRGBA*"}, name ={"colorchooser", "color"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    rgba          = {__type__="GdkRGBA*"                       , __gencode__ = {"gtk_color_chooser_set_rgba((GtkColorChooser*)({* id *}), (const GdkRGBA*)({* property.value *}))"} },
    ["use-alpha"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_color_chooser_set_use_alpha((GtkColorChooser*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkConstraintTarget
Gtk418.GtkConstraintTarget = {
  class = "GtkConstraintTarget", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkEditable
Gtk418.GtkEditable = {
  class = "GtkEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed              = {"void"        , {"GtkEditable*"}, {"editable"} }, 
    delete_text          = {"void"        , {"GtkEditable*", "int", "int"}, {"editable", "start_pos", "end_pos"} }, 
    do_delete_text       = {"void"        , {"GtkEditable*", "int", "int"}, {"editable", "start_pos", "end_pos"} }, 
    do_insert_text       = {"void"        , {"GtkEditable*", "const char*", "int", "int*"}, {"editable", "text", "length", "position"} }, 
    get_delegate         = {"GtkEditable*", {"GtkEditable*"}, {"editable"} }, 
    get_selection_bounds = {"gboolean"    , {"GtkEditable*", "int*", "int*"}, {"editable", "start_pos", "end_pos"} }, 
    get_text             = {"const char*" , {"GtkEditable*"}, {"editable"} }, 
    insert_text          = {"void"        , {"GtkEditable*", "const char*", "int", "int*"}, {"editable", "text", "length", "position"} }, 
    set_selection_bounds = {"void"        , {"GtkEditable*", "int", "int"}, {"editable", "start_pos", "end_pos"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed         = {ret_type = "void", params = {type = {"GtkEditable*"}, name ={"editable"}} }, 
    ['delete-text'] = {ret_type = "void", params = {type = {"GtkEditable*", "gint", "gint"}, name ={"editable", "start_pos", "end_pos"}} }, 
    ['insert-text'] = {ret_type = "void", params = {type = {"GtkEditable*", "gchar*", "gint", "gpointer"}, name ={"editable", "text", "length", "position"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cursor-position"] = {__type__="gint"     ,__default__ = "0"     },
    editable            = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_editable_set_editable((GtkEditable*)({* id *}), (gboolean)({* property.value *}))"} },
    ["enable-undo"]     = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_editable_set_enable_undo((GtkEditable*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-width-chars"] = {__type__="gint"     ,__default__ = "-1"   , __gencode__ = {"gtk_editable_set_max_width_chars((GtkEditable*)({* id *}), (int)({* property.value *}))"} },
    ["selection-bound"] = {__type__="gint"     ,__default__ = "0"     },
    text                = {__type__="gchar*"   ,__default__ = "\"\"" , __gencode__ = {"gtk_editable_set_text((GtkEditable*)({* id *}), (const char*)({* property.value *}))"} },
    ["width-chars"]     = {__type__="gint"     ,__default__ = "-1"   , __gencode__ = {"gtk_editable_set_width_chars((GtkEditable*)({* id *}), (int)({* property.value *}))"} },
    xalign              = {__type__="gfloat"   ,__default__ = "0"    ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkFileChooser
Gtk418.GtkFileChooser = {
  class = "GtkFileChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    action               = {__type__="GtkFileChooserAction" ,__default__ = "GTK_FILE_CHOOSER_ACTION_OPEN" , __gencode__ = {"gtk_file_chooser_set_action((GtkFileChooser*)({* id *}), (GtkFileChooserAction)({* property.value *}))"} },
    ["create-folders"]   = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_create_folders((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    filter               = {__type__="GtkFileFilter*"                                                     , __gencode__ = {"gtk_file_chooser_set_filter((GtkFileChooser*)({* id *}), (GtkFileFilter*)({* property.value *}))"} },
    filters              = {__type__="GListModel*"                                                         },
    ["select-multiple"]  = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_select_multiple((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["shortcut-folders"] = {__type__="GListModel*"                                                         },
  },
  parent = nil, 
};

---------------------  GtkFontChooser
Gtk418.GtkFontChooser = {
  class = "GtkFontChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    font_activated  = {"void"            , {"GtkFontChooser*", "const char*"}, {"chooser", "fontname"} }, 
    get_font_face   = {"PangoFontFace*"  , {"GtkFontChooser*"}, {"fontchooser"} }, 
    get_font_family = {"PangoFontFamily*", {"GtkFontChooser*"}, {"fontchooser"} }, 
    get_font_map    = {"PangoFontMap*"   , {"GtkFontChooser*"}, {"fontchooser"} }, 
    get_font_size   = {"int"             , {"GtkFontChooser*"}, {"fontchooser"} }, 
    set_filter_func = {"void"            , {"GtkFontChooser*", "GtkFontFilterFunc", "gpointer", "GDestroyNotify"}, {"fontchooser", "filter", "user_data", "destroy"} }, 
    set_font_map    = {"void"            , {"GtkFontChooser*", "PangoFontMap*"}, {"fontchooser", "fontmap"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['font-activated'] = {ret_type = "void", params = {type = {"GtkFontChooser*", "gchar*"}, name ={"fontchooser", "fontname"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    font                   = {__type__="gchar*"                ,__default__ = "\"Sans 10\""                                                , __gencode__ = {"gtk_font_chooser_set_font((GtkFontChooser*)({* id *}), (const char*)({* property.value *}))"} },
    ["font-desc"]          = {__type__="PangoFontDescription*"                                                                             , __gencode__ = {"gtk_font_chooser_set_font_desc((GtkFontChooser*)({* id *}), (const PangoFontDescription*)({* property.value *}))"} },
    ["font-features"]      = {__type__="gchar*"                ,__default__ = "\"\""                                                        },
    language               = {__type__="gchar*"                ,__default__ = "\"\""                                                       , __gencode__ = {"gtk_font_chooser_set_language((GtkFontChooser*)({* id *}), (const char*)({* property.value *}))"} },
    level                  = {__type__="GtkFontChooserLevel"   ,__default__ = "GTK_FONT_CHOOSER_LEVEL_STYLE | GTK_FONT_CHOOSER_LEVEL_SIZE" , __gencode__ = {"gtk_font_chooser_set_level((GtkFontChooser*)({* id *}), (GtkFontChooserLevel)({* property.value *}))"} },
    ["preview-text"]       = {__type__="gchar*"                ,__default__ = "\"The quick brown fox jumps over the lazy dog.\""           , __gencode__ = {"gtk_font_chooser_set_preview_text((GtkFontChooser*)({* id *}), (const char*)({* property.value *}))"} },
    ["show-preview-entry"] = {__type__="gboolean"              ,__default__ = "TRUE"                                                       , __gencode__ = {"gtk_font_chooser_set_show_preview_entry((GtkFontChooser*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkNative
Gtk418.GtkNative = {
  class = "GtkNative", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkOrientable
Gtk418.GtkOrientable = {
  class = "GtkOrientable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL" , __gencode__ = {"gtk_orientable_set_orientation((GtkOrientable*)({* id *}), (GtkOrientation)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPrintOperationPreview
Gtk418.GtkPrintOperationPreview = {
  class = "GtkPrintOperationPreview", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    end_preview   = {"void"    , {"GtkPrintOperationPreview*"}, {"preview"} }, 
    got_page_size = {"void"    , {"GtkPrintOperationPreview*", "GtkPrintContext*", "GtkPageSetup*"}, {"preview", "context", "page_setup"} }, 
    is_selected   = {"gboolean", {"GtkPrintOperationPreview*", "int"}, {"preview", "page_nr"} }, 
    ready         = {"void"    , {"GtkPrintOperationPreview*", "GtkPrintContext*"}, {"preview", "context"} }, 
    render_page   = {"void"    , {"GtkPrintOperationPreview*", "int"}, {"preview", "page_nr"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['got-page-size'] = {ret_type = "void", params = {type = {"GtkPrintOperationPreview*", "GtkPrintContext*", "GtkPageSetup*"}, name ={"printoperationpreview", "context", "page_setup"}} }, 
    ready             = {ret_type = "void", params = {type = {"GtkPrintOperationPreview*", "GtkPrintContext*"}, name ={"preview", "context"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRoot
Gtk418.GtkRoot = {
  class = "GtkRoot", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkScrollable
Gtk418.GtkScrollable = {
  class = "GtkScrollable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_border = {"gboolean", {"GtkScrollable*", "GtkBorder*"}, {"scrollable", "border"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hadjustment        = {__type__="GtkAdjustment*"                                          , __gencode__ = {"gtk_scrollable_set_hadjustment((GtkScrollable*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["hscroll-policy"] = {__type__="GtkScrollablePolicy" ,__default__ = "GTK_SCROLL_MINIMUM" , __gencode__ = {"gtk_scrollable_set_hscroll_policy((GtkScrollable*)({* id *}), (GtkScrollablePolicy)({* property.value *}))"} },
    vadjustment        = {__type__="GtkAdjustment*"                                          , __gencode__ = {"gtk_scrollable_set_vadjustment((GtkScrollable*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["vscroll-policy"] = {__type__="GtkScrollablePolicy" ,__default__ = "GTK_SCROLL_MINIMUM" , __gencode__ = {"gtk_scrollable_set_vscroll_policy((GtkScrollable*)({* id *}), (GtkScrollablePolicy)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkSectionModel
Gtk418.GtkSectionModel = {
  class = "GtkSectionModel", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_section = {"void", {"GtkSectionModel*", "guint", "guint*", "guint*"}, {"self", "position", "out_start", "out_end"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['sections-changed'] = {ret_type = "void", params = {type = {"GtkSectionModel*", "guint", "guint"}, name ={"sectionmodel", "position", "n_items"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkSelectionModel
Gtk418.GtkSelectionModel = {
  class = "GtkSelectionModel", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_selection_in_range = {"GtkBitset*", {"GtkSelectionModel*", "guint", "guint"}, {"model", "position", "n_items"} }, 
    is_selected            = {"gboolean"  , {"GtkSelectionModel*", "guint"}, {"model", "position"} }, 
    select_all             = {"gboolean"  , {"GtkSelectionModel*"}, {"model"} }, 
    select_item            = {"gboolean"  , {"GtkSelectionModel*", "guint", "gboolean"}, {"model", "position", "unselect_rest"} }, 
    select_range           = {"gboolean"  , {"GtkSelectionModel*", "guint", "guint", "gboolean"}, {"model", "position", "n_items", "unselect_rest"} }, 
    set_selection          = {"gboolean"  , {"GtkSelectionModel*", "GtkBitset*", "GtkBitset*"}, {"model", "selected", "mask"} }, 
    unselect_all           = {"gboolean"  , {"GtkSelectionModel*"}, {"model"} }, 
    unselect_item          = {"gboolean"  , {"GtkSelectionModel*", "guint"}, {"model", "position"} }, 
    unselect_range         = {"gboolean"  , {"GtkSelectionModel*", "guint", "guint"}, {"model", "position", "n_items"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['selection-changed'] = {ret_type = "void", params = {type = {"GtkSelectionModel*", "guint", "guint"}, name ={"selectionmodel", "position", "n_items"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkShortcutManager
Gtk418.GtkShortcutManager = {
  class = "GtkShortcutManager", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_controller    = {"void", {"GtkShortcutManager*", "GtkShortcutController*"}, {"self", "controller"} }, 
    remove_controller = {"void", {"GtkShortcutManager*", "GtkShortcutController*"}, {"self", "controller"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkStyleProvider
Gtk418.GtkStyleProvider = {
  class = "GtkStyleProvider", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['gtk-private-changed'] = {ret_type = "void", params = {type = {"GtkStyleProvider*"}, name ={"styleprovider"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkSymbolicPaintable
Gtk418.GtkSymbolicPaintable = {
  class = "GtkSymbolicPaintable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    snapshot_symbolic = {"void", {"GtkSymbolicPaintable*", "GdkSnapshot*", "double", "double", "const GdkRGBA*", "gsize"}, {"paintable", "snapshot", "width", "height", "colors", "n_colors"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeDragDest
Gtk418.GtkTreeDragDest = {
  class = "GtkTreeDragDest", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    drag_data_received = {"gboolean", {"GtkTreeDragDest*", "GtkTreePath*", "const GValue*"}, {"drag_dest", "dest", "value"} }, 
    row_drop_possible  = {"gboolean", {"GtkTreeDragDest*", "GtkTreePath*", "const GValue*"}, {"drag_dest", "dest_path", "value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeDragSource
Gtk418.GtkTreeDragSource = {
  class = "GtkTreeDragSource", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    drag_data_delete = {"gboolean"           , {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
    drag_data_get    = {"GdkContentProvider*", {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
    row_draggable    = {"gboolean"           , {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeModel
Gtk418.GtkTreeModel = {
  class = "GtkTreeModel", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_column_type       = {"GType"            , {"GtkTreeModel*", "int"}, {"tree_model", "index_"} }, 
    get_flags             = {"GtkTreeModelFlags", {"GtkTreeModel*"}, {"tree_model"} }, 
    get_iter              = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_model", "iter", "path"} }, 
    get_n_columns         = {"int"              , {"GtkTreeModel*"}, {"tree_model"} }, 
    get_path              = {"GtkTreePath*"     , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    get_value             = {"void"             , {"GtkTreeModel*", "GtkTreeIter*", "int", "GValue*"}, {"tree_model", "iter", "column", "value"} }, 
    iter_children         = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*"}, {"tree_model", "iter", "parent"} }, 
    iter_has_child        = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_n_children       = {"int"              , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_next             = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_nth_child        = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*", "int"}, {"tree_model", "iter", "parent", "n"} }, 
    iter_parent           = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*"}, {"tree_model", "iter", "child"} }, 
    iter_previous         = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    ref_node              = {"void"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    row_changed           = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    row_deleted           = {"void"             , {"GtkTreeModel*", "GtkTreePath*"}, {"tree_model", "path"} }, 
    row_has_child_toggled = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    row_inserted          = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    rows_reordered        = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*", "int*"}, {"tree_model", "path", "iter", "new_order"} }, 
    unref_node            = {"void"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['row-changed']           = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['row-deleted']           = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*"}, name ={"treemodel", "path"}} }, 
    ['row-has-child-toggled'] = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['row-inserted']          = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['rows-reordered']        = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*", "gpointer"}, name ={"treemodel", "path", "iter", "new_order"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeSortable
Gtk418.GtkTreeSortable = {
  class = "GtkTreeSortable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_sort_column_id    = {"gboolean", {"GtkTreeSortable*", "int*", "GtkSortType*"}, {"sortable", "sort_column_id", "order"} }, 
    has_default_sort_func = {"gboolean", {"GtkTreeSortable*"}, {"sortable"} }, 
    set_default_sort_func = {"void"    , {"GtkTreeSortable*", "GtkTreeIterCompareFunc", "gpointer", "GDestroyNotify"}, {"sortable", "sort_func", "user_data", "destroy"} }, 
    set_sort_column_id    = {"void"    , {"GtkTreeSortable*", "int", "GtkSortType"}, {"sortable", "sort_column_id", "order"} }, 
    set_sort_func         = {"void"    , {"GtkTreeSortable*", "int", "GtkTreeIterCompareFunc", "gpointer", "GDestroyNotify"}, {"sortable", "sort_column_id", "sort_func", "user_data", "destroy"} }, 
    sort_column_changed   = {"void"    , {"GtkTreeSortable*"}, {"sortable"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['sort-column-changed'] = {ret_type = "void", params = {type = {"GtkTreeSortable*"}, name ={"treesortable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

----  [Gtk interfaces] End ... 
----  [Gtk Classes] Start 
---------------------  GtkATContext
Gtk418.GtkATContext = {
  class = "GtkATContext", 
  constructor = { 
    -- 名称[- ==> _], 
    create = { gencode = "gtk_at_context_create((GtkAccessibleRole)({* this['accessible-role']value *}), (GtkAccessible*)({* this.accessible.value *}), (GdkDisplay*)({* this.display.value *}))", 
            params = { type = {"GtkAccessibleRole", "GtkAccessible*", "GdkDisplay*"}, 
                       name = {"accessible-role", "accessible", "display"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['state-change'] = {ret_type = "void", params = {type = {"GtkATContext*"}, name ={"atcontext"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accessible          = {__type__="GtkAccessible*"                                              ,rwflags="rw" },
    ["accessible-role"] = {__type__="GtkAccessibleRole" ,__default__ = "GTK_ACCESSIBLE_ROLE_NONE" ,rwflags="rw",__construct__= 1 },
    display             = {__type__="GdkDisplay*"                                                 ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkAdjustment
Gtk418.GtkAdjustment = {
  class = "GtkAdjustment", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_adjustment_new((double)({* this.value.value *}), (double)({* this.lower.value *}), (double)({* this.upper.value *}), (double)({* this['step-increment'].value *}), (double)({* this['page-increment'].value *}), (double)({* this['page-size'].value *}))", 
            params = { type = {"double", "double", "double", "double", "double", "double"}, 
                       name = {"value", "lower", "upper", "step-increment", "page-increment", "page-size"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed       = {"void", {"GtkAdjustment*"}, {"adjustment"} }, 
    value_changed = {"void", {"GtkAdjustment*"}, {"adjustment"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed           = {ret_type = "void", params = {type = {"GtkAdjustment*"}, name ={"adjustment"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkAdjustment*"}, name ={"adjustment"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    lower              = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_lower((GtkAdjustment*)({* id *}), (double)({* property.value *}))"} },
    ["page-increment"] = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_page_increment((GtkAdjustment*)({* id *}), (double)({* property.value *}))"} },
    ["page-size"]      = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_page_size((GtkAdjustment*)({* id *}), (double)({* property.value *}))"} },
    ["step-increment"] = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_step_increment((GtkAdjustment*)({* id *}), (double)({* property.value *}))"} },
    upper              = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_upper((GtkAdjustment*)({* id *}), (double)({* property.value *}))"} },
    value              = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_value((GtkAdjustment*)({* id *}), (double)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkAlertDialog
Gtk418.GtkAlertDialog = {
  class = "GtkAlertDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_alert_dialog_new((const char*)({* this.format.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    buttons            = {__type__="GStrv"                          , __gencode__ = {"gtk_alert_dialog_set_buttons((GtkAlertDialog*)({* id *}), (const char* const*)({* property.value *}))"} },
    ["cancel-button"]  = {__type__="gint"     ,__default__ = "-1"   , __gencode__ = {"gtk_alert_dialog_set_cancel_button((GtkAlertDialog*)({* id *}), (int)({* property.value *}))"} },
    ["default-button"] = {__type__="gint"     ,__default__ = "-1"   , __gencode__ = {"gtk_alert_dialog_set_default_button((GtkAlertDialog*)({* id *}), (int)({* property.value *}))"} },
    detail             = {__type__="gchar*"   ,__default__ = "NULL" , __gencode__ = {"gtk_alert_dialog_set_detail((GtkAlertDialog*)({* id *}), (const char*)({* property.value *}))"} },
    message            = {__type__="gchar*"   ,__default__ = "NULL" , __gencode__ = {"gtk_alert_dialog_set_message((GtkAlertDialog*)({* id *}), (const char*)({* property.value *}))"} },
    modal              = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_alert_dialog_set_modal((GtkAlertDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkApplication
Gtk418.GtkApplication = {
  class = "GtkApplication", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_application_new((const char*)({* this.application_id.value *}), (GApplicationFlags)({* this.flags.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    window_added   = {"void", {"GtkApplication*", "GtkWindow*"}, {"application", "window"} }, 
    window_removed = {"void", {"GtkApplication*", "GtkWindow*"}, {"application", "window"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['query-end']      = {ret_type = "void", params = {type = {"GtkApplication*"}, name ={"application"}} }, 
    ['window-added']   = {ret_type = "void", params = {type = {"GtkApplication*", "GtkWindow*"}, name ={"application", "window"}} }, 
    ['window-removed'] = {ret_type = "void", params = {type = {"GtkApplication*", "GtkWindow*"}, name ={"application", "window"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["active-window"]      = {__type__="GtkWindow*"                          },
    menubar                = {__type__="GMenuModel*"                        , __gencode__ = {"gtk_application_set_menubar((GtkApplication*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["register-session"]   = {__type__="gboolean"    ,__default__ = "FALSE" ,rwflags="rw" },
    ["screensaver-active"] = {__type__="gboolean"    ,__default__ = "FALSE"  },
  },
  parent = nil, 
};

---------------------  GtkAssistantPage
Gtk418.GtkAssistantPage = {
  class = "GtkAssistantPage", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child         = {__type__="GtkWidget*"                                                       ,rwflags="rw" },
    complete      = {__type__="gboolean"             ,__default__ = "FALSE"                      ,rwflags="rw" },
    ["page-type"] = {__type__="GtkAssistantPageType" ,__default__ = "GTK_ASSISTANT_PAGE_CONTENT" ,rwflags="rw" },
    title         = {__type__="gchar*"               ,__default__ = "NULL"                       ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkBookmarkList
Gtk418.GtkBookmarkList = {
  class = "GtkBookmarkList", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_bookmark_list_new((const char*)({* this.filename.value *}), (const char*)({* this.attributes.value *}))", 
            params = { type = {"const char*", "const char*"}, 
                       name = {"filename", "attributes"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    attributes      = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_bookmark_list_set_attributes((GtkBookmarkList*)({* id *}), (const char*)({* property.value *}))"} },
    filename        = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
    ["io-priority"] = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_bookmark_list_set_io_priority((GtkBookmarkList*)({* id *}), (int)({* property.value *}))"} },
    ["item-type"]   = {__type__="GType"                            },
    loading         = {__type__="gboolean" ,__default__ = "FALSE"  },
    ["n-items"]     = {__type__="guint"    ,__default__ = "0"      },
  },
  parent = nil, 
};

---------------------  GtkBuilder
Gtk418.GtkBuilder = {
  class = "GtkBuilder", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_builder_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_builder_new_from_file((const char*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_resource = { gencode = "gtk_builder_new_from_resource((const char*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
    new_from_string   = { gencode = "gtk_builder_new_from_string((const char*)({* this.string.value *}), (gssize)({* this.length.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["current-object"]     = {__type__="GObject*"                               , __gencode__ = {"gtk_builder_set_current_object((GtkBuilder*)({* id *}), (GObject*)({* property.value *}))"} },
    scope                  = {__type__="GtkBuilderScope*"                       , __gencode__ = {"gtk_builder_set_scope((GtkBuilder*)({* id *}), (GtkBuilderScope*)({* property.value *}))"},__construct__= 1 },
    ["translation-domain"] = {__type__="gchar*"           ,__default__ = "NULL" , __gencode__ = {"gtk_builder_set_translation_domain((GtkBuilder*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkBuilderCScope
Gtk418.GtkBuilderCScope = {
  class = "GtkBuilderCScope", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_builder_cscope_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk418.GtkBuilderScope}, 
};

---------------------  GtkCellArea
Gtk418.GtkCellArea = {
  class = "GtkCellArea", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate                       = {"gboolean"           , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "const GdkRectangle*", "GtkCellRendererState", "gboolean"}, {"area", "context", "widget", "cell_area", "flags", "edit_only"} }, 
    add                            = {"void"               , {"GtkCellArea*", "GtkCellRenderer*"}, {"area", "renderer"} }, 
    apply_attributes               = {"void"               , {"GtkCellArea*", "GtkTreeModel*", "GtkTreeIter*", "gboolean", "gboolean"}, {"area", "tree_model", "iter", "is_expander", "is_expanded"} }, 
    copy_context                   = {"GtkCellAreaContext*", {"GtkCellArea*", "GtkCellAreaContext*"}, {"area", "context"} }, 
    create_context                 = {"GtkCellAreaContext*", {"GtkCellArea*"}, {"area"} }, 
    event                          = {"int"                , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "GdkEvent*", "const GdkRectangle*", "GtkCellRendererState"}, {"area", "context", "widget", "event", "cell_area", "flags"} }, 
    focus                          = {"gboolean"           , {"GtkCellArea*", "GtkDirectionType"}, {"area", "direction"} }, 
    foreach                        = {"void"               , {"GtkCellArea*", "GtkCellCallback", "gpointer"}, {"area", "callback", "callback_data"} }, 
    foreach_alloc                  = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellAllocCallback", "gpointer"}, {"area", "context", "widget", "cell_area", "background_area", "callback", "callback_data"} }, 
    get_cell_property              = {"void"               , {"GtkCellArea*", "GtkCellRenderer*", "guint", "GValue*", "GParamSpec*"}, {"area", "renderer", "property_id", "value", "pspec"} }, 
    get_preferred_height           = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "int*", "int*"}, {"area", "context", "widget", "minimum_height", "natural_height"} }, 
    get_preferred_height_for_width = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "int", "int*", "int*"}, {"area", "context", "widget", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width            = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "int*", "int*"}, {"area", "context", "widget", "minimum_width", "natural_width"} }, 
    get_preferred_width_for_height = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "int", "int*", "int*"}, {"area", "context", "widget", "height", "minimum_width", "natural_width"} }, 
    get_request_mode               = {"GtkSizeRequestMode" , {"GtkCellArea*"}, {"area"} }, 
    is_activatable                 = {"gboolean"           , {"GtkCellArea*"}, {"area"} }, 
    remove                         = {"void"               , {"GtkCellArea*", "GtkCellRenderer*"}, {"area", "renderer"} }, 
    set_cell_property              = {"void"               , {"GtkCellArea*", "GtkCellRenderer*", "guint", "const GValue*", "GParamSpec*"}, {"area", "renderer", "property_id", "value", "pspec"} }, 
    snapshot                       = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "GtkSnapshot*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState", "gboolean"}, {"area", "context", "widget", "snapshot", "background_area", "cell_area", "flags", "paint_focus"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['add-editable']     = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkCellRenderer*", "GtkCellEditable*", "GdkRectangle*", "gchar*"}, name ={"cellarea", "renderer", "editable", "cell_area", "path"}} }, 
    ['apply-attributes'] = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkTreeModel*", "GtkTreeIter*", "gboolean", "gboolean"}, name ={"cellarea", "model", "iter", "is_expander", "is_expanded"}} }, 
    ['focus-changed']    = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkCellRenderer*", "gchar*"}, name ={"cellarea", "renderer", "path"}} }, 
    ['remove-editable']  = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkCellRenderer*", "GtkCellEditable*"}, name ={"cellarea", "renderer", "editable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["edit-widget"] = {__type__="GtkCellEditable*"  },
    ["edited-cell"] = {__type__="GtkCellRenderer*"  },
    ["focus-cell"]  = {__type__="GtkCellRenderer*" , __gencode__ = {"gtk_cell_area_set_focus_cell((GtkCellArea*)({* id *}), (GtkCellRenderer*)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable, Gtk418.GtkCellLayout}, 
};

---------------------  GtkCellAreaContext
Gtk418.GtkCellAreaContext = {
  class = "GtkCellAreaContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    allocate                       = {"void", {"GtkCellAreaContext*", "int", "int"}, {"context", "width", "height"} }, 
    get_preferred_height_for_width = {"void", {"GtkCellAreaContext*", "int", "int*", "int*"}, {"context", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width_for_height = {"void", {"GtkCellAreaContext*", "int", "int*", "int*"}, {"context", "height", "minimum_width", "natural_width"} }, 
    reset                          = {"void", {"GtkCellAreaContext*"}, {"context"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    area               = {__type__="GtkCellArea*"                     ,rwflags="rw" },
    ["minimum-height"] = {__type__="gint"         ,__default__ = "-1"  },
    ["minimum-width"]  = {__type__="gint"         ,__default__ = "-1"  },
    ["natural-height"] = {__type__="gint"         ,__default__ = "-1"  },
    ["natural-width"]  = {__type__="gint"         ,__default__ = "-1"  },
  },
  parent = nil, 
};

---------------------  GtkCellRenderer
Gtk418.GtkCellRenderer = {
  class = "GtkCellRenderer", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate                       = {"gboolean"          , {"GtkCellRenderer*", "GdkEvent*", "GtkWidget*", "const char*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState"}, {"cell", "event", "widget", "path", "background_area", "cell_area", "flags"} }, 
    editing_canceled               = {"void"              , {"GtkCellRenderer*"}, {"cell"} }, 
    editing_started                = {"void"              , {"GtkCellRenderer*", "GtkCellEditable*", "const char*"}, {"cell", "editable", "path"} }, 
    get_aligned_area               = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "GtkCellRendererState", "const GdkRectangle*", "GdkRectangle*"}, {"cell", "widget", "flags", "cell_area", "aligned_area"} }, 
    get_preferred_height           = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "int*", "int*"}, {"cell", "widget", "minimum_size", "natural_size"} }, 
    get_preferred_height_for_width = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "int", "int*", "int*"}, {"cell", "widget", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width            = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "int*", "int*"}, {"cell", "widget", "minimum_size", "natural_size"} }, 
    get_preferred_width_for_height = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "int", "int*", "int*"}, {"cell", "widget", "height", "minimum_width", "natural_width"} }, 
    get_request_mode               = {"GtkSizeRequestMode", {"GtkCellRenderer*"}, {"cell"} }, 
    snapshot                       = {"void"              , {"GtkCellRenderer*", "GtkSnapshot*", "GtkWidget*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState"}, {"cell", "snapshot", "widget", "background_area", "cell_area", "flags"} }, 
    start_editing                  = {"GtkCellEditable*"  , {"GtkCellRenderer*", "GdkEvent*", "GtkWidget*", "const char*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState"}, {"cell", "event", "widget", "path", "background_area", "cell_area", "flags"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['editing-canceled'] = {ret_type = "void", params = {type = {"GtkCellRenderer*"}, name ={"cellrenderer"}} }, 
    ['editing-started']  = {ret_type = "void", params = {type = {"GtkCellRenderer*", "GtkCellEditable*", "gchar*"}, name ={"cellrenderer", "editable", "path"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cell-background"]      = {__type__="gchar*"              ,__default__ = "NULL"                         ,rwflags="w" },
    ["cell-background-rgba"] = {__type__="GdkRGBA*"                                                          ,rwflags="rw" },
    ["cell-background-set"]  = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    editing                  = {__type__="gboolean"            ,__default__ = "FALSE"                         },
    height                   = {__type__="gint"                ,__default__ = "-1"                           ,rwflags="rw" },
    ["is-expanded"]          = {__type__="gboolean"            ,__default__ = "FALSE"                        , __gencode__ = {"gtk_cell_renderer_set_is_expanded((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    ["is-expander"]          = {__type__="gboolean"            ,__default__ = "FALSE"                        , __gencode__ = {"gtk_cell_renderer_set_is_expander((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    mode                     = {__type__="GtkCellRendererMode" ,__default__ = "GTK_CELL_RENDERER_MODE_INERT" ,rwflags="rw" },
    sensitive                = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_cell_renderer_set_sensitive((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    visible                  = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_cell_renderer_set_visible((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    width                    = {__type__="gint"                ,__default__ = "-1"                           ,rwflags="rw" },
    xalign                   = {__type__="gfloat"              ,__default__ = "0.5"                          ,rwflags="rw" },
    xpad                     = {__type__="guint"               ,__default__ = "0"                            ,rwflags="rw" },
    yalign                   = {__type__="gfloat"              ,__default__ = "0.5"                          ,rwflags="rw" },
    ypad                     = {__type__="guint"               ,__default__ = "0"                            ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkColorDialog
Gtk418.GtkColorDialog = {
  class = "GtkColorDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    modal          = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_color_dialog_set_modal((GtkColorDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    title          = {__type__="gchar*"   ,__default__ = "NULL" , __gencode__ = {"gtk_color_dialog_set_title((GtkColorDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["with-alpha"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_color_dialog_set_with_alpha((GtkColorDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkColumnViewColumn
Gtk418.GtkColumnViewColumn = {
  class = "GtkColumnViewColumn", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_column_view_column_new((const char*)({* this.title.value *}), (GtkListItemFactory*)({* this.factory.value *}))", 
            params = { type = {"const char*", "GtkListItemFactory*"}, 
                       name = {"title", "factory"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["column-view"] = {__type__="GtkColumnView*"                              },
    expand          = {__type__="gboolean"            ,__default__ = "FALSE" , __gencode__ = {"gtk_column_view_column_set_expand((GtkColumnViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    factory         = {__type__="GtkListItemFactory*"                        , __gencode__ = {"gtk_column_view_column_set_factory((GtkColumnViewColumn*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    ["fixed-width"] = {__type__="gint"                ,__default__ = "-1"    , __gencode__ = {"gtk_column_view_column_set_fixed_width((GtkColumnViewColumn*)({* id *}), (int)({* property.value *}))"} },
    ["header-menu"] = {__type__="GMenuModel*"                                , __gencode__ = {"gtk_column_view_column_set_header_menu((GtkColumnViewColumn*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    id              = {__type__="gchar*"              ,__default__ = "NULL"  , __gencode__ = {"gtk_column_view_column_set_id((GtkColumnViewColumn*)({* id *}), (const char*)({* property.value *}))"} },
    resizable       = {__type__="gboolean"            ,__default__ = "FALSE" , __gencode__ = {"gtk_column_view_column_set_resizable((GtkColumnViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    sorter          = {__type__="GtkSorter*"                                 , __gencode__ = {"gtk_column_view_column_set_sorter((GtkColumnViewColumn*)({* id *}), (GtkSorter*)({* property.value *}))"} },
    title           = {__type__="gchar*"              ,__default__ = "NULL"  , __gencode__ = {"gtk_column_view_column_set_title((GtkColumnViewColumn*)({* id *}), (const char*)({* property.value *}))"} },
    visible         = {__type__="gboolean"            ,__default__ = "TRUE"  , __gencode__ = {"gtk_column_view_column_set_visible((GtkColumnViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkColumnViewRow
Gtk418.GtkColumnViewRow = {
  class = "GtkColumnViewRow", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accessible-description"] = {__type__="gchar*"   ,__default__ = "NULL"       , __gencode__ = {"gtk_column_view_row_set_accessible_description((GtkColumnViewRow*)({* id *}), (const char*)({* property.value *}))"} },
    ["accessible-label"]       = {__type__="gchar*"   ,__default__ = "NULL"       , __gencode__ = {"gtk_column_view_row_set_accessible_label((GtkColumnViewRow*)({* id *}), (const char*)({* property.value *}))"} },
    activatable                = {__type__="gboolean" ,__default__ = "TRUE"       , __gencode__ = {"gtk_column_view_row_set_activatable((GtkColumnViewRow*)({* id *}), (gboolean)({* property.value *}))"} },
    focusable                  = {__type__="gboolean" ,__default__ = "TRUE"       , __gencode__ = {"gtk_column_view_row_set_focusable((GtkColumnViewRow*)({* id *}), (gboolean)({* property.value *}))"} },
    item                       = {__type__="GObject*"                              },
    position                   = {__type__="guint"    ,__default__ = "4294967295"  },
    selectable                 = {__type__="gboolean" ,__default__ = "TRUE"       , __gencode__ = {"gtk_column_view_row_set_selectable((GtkColumnViewRow*)({* id *}), (gboolean)({* property.value *}))"} },
    selected                   = {__type__="gboolean" ,__default__ = "FALSE"       },
  },
  parent = nil, 
};

---------------------  GtkConstraint
Gtk418.GtkConstraint = {
  class = "GtkConstraint", 
  constructor = { 
    -- 名称[- ==> _], 
    new          = { gencode = "gtk_constraint_new((gpointer)({* this.target.value *}), (GtkConstraintAttribute)({* this['target-attribute'].value *}), (GtkConstraintRelation)({* this.relation.value *}), (gpointer)({* this.source.value *}), (GtkConstraintAttribute)({* this['source-attribute'].value *}), (double)({* this.multiplier.value *}), (double)({* this.constant.value *}), (int)({* this.strength.value *}))", 
            params = { type = {"gpointer", "GtkConstraintAttribute", "GtkConstraintRelation", "gpointer", "GtkConstraintAttribute", "double", "double", "int"}, 
                       name = {"target", "target-attribute", "relation", "source", "source-attribute", "multiplier", "constant", "strength"} } },
    new_constant = { gencode = "gtk_constraint_new_constant((gpointer)({* this.target.value *}), (GtkConstraintAttribute)({* this['target-attribute'].value *}), (GtkConstraintRelation)({* this.relation.value *}), (double)({* this.constant.value *}), (int)({* this.strength.value *}))", 
            params = { type = {"gpointer", "GtkConstraintAttribute", "GtkConstraintRelation", "double", "int"}, 
                       name = {"target", "target-attribute", "relation", "constant", "strength"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    constant             = {__type__="gdouble"                ,__default__ = "0"                             ,rwflags="rw" },
    multiplier           = {__type__="gdouble"                ,__default__ = "1"                             ,rwflags="rw" },
    relation             = {__type__="GtkConstraintRelation"  ,__default__ = "GTK_CONSTRAINT_RELATION_EQ"    ,rwflags="rw" },
    source               = {__type__="GtkConstraintTarget*"                                                  ,rwflags="rw" },
    ["source-attribute"] = {__type__="GtkConstraintAttribute" ,__default__ = "GTK_CONSTRAINT_ATTRIBUTE_NONE" ,rwflags="rw" },
    strength             = {__type__="gint"                   ,__default__ = "1001001000"                    ,rwflags="rw" },
    target               = {__type__="GtkConstraintTarget*"                                                  ,rwflags="rw" },
    ["target-attribute"] = {__type__="GtkConstraintAttribute" ,__default__ = "GTK_CONSTRAINT_ATTRIBUTE_NONE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkConstraintGuide
Gtk418.GtkConstraintGuide = {
  class = "GtkConstraintGuide", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_constraint_guide_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["max-height"] = {__type__="gint"                  ,__default__ = "2147483647"                     ,rwflags="rw" },
    ["max-width"]  = {__type__="gint"                  ,__default__ = "2147483647"                     ,rwflags="rw" },
    ["min-height"] = {__type__="gint"                  ,__default__ = "0"                              ,rwflags="rw" },
    ["min-width"]  = {__type__="gint"                  ,__default__ = "0"                              ,rwflags="rw" },
    name           = {__type__="gchar*"                ,__default__ = "NULL"                           , __gencode__ = {"gtk_constraint_guide_set_name((GtkConstraintGuide*)({* id *}), (const char*)({* property.value *}))"} },
    ["nat-height"] = {__type__="gint"                  ,__default__ = "0"                              ,rwflags="rw" },
    ["nat-width"]  = {__type__="gint"                  ,__default__ = "0"                              ,rwflags="rw" },
    strength       = {__type__="GtkConstraintStrength" ,__default__ = "GTK_CONSTRAINT_STRENGTH_MEDIUM" , __gencode__ = {"gtk_constraint_guide_set_strength((GtkConstraintGuide*)({* id *}), (GtkConstraintStrength)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkCssProvider
Gtk418.GtkCssProvider = {
  class = "GtkCssProvider", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_css_provider_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['parsing-error'] = {ret_type = "void", params = {type = {"GtkCssProvider*", "GtkCssSection*", "GError*"}, name ={"cssprovider", "section", "error"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk418.GtkStyleProvider}, 
};

---------------------  GtkDirectoryList
Gtk418.GtkDirectoryList = {
  class = "GtkDirectoryList", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_directory_list_new((const char*)({* this.attributes.value *}), (GFile*)({* this.file.value *}))", 
            params = { type = {"const char*", "GFile*"}, 
                       name = {"attributes", "file"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    attributes      = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_directory_list_set_attributes((GtkDirectoryList*)({* id *}), (const char*)({* property.value *}))"} },
    error           = {__type__="GError*"                          },
    file            = {__type__="GFile*"                          , __gencode__ = {"gtk_directory_list_set_file((GtkDirectoryList*)({* id *}), (GFile*)({* property.value *}))"} },
    ["io-priority"] = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_directory_list_set_io_priority((GtkDirectoryList*)({* id *}), (int)({* property.value *}))"} },
    ["item-type"]   = {__type__="GType"                            },
    loading         = {__type__="gboolean" ,__default__ = "FALSE"  },
    monitored       = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_directory_list_set_monitored((GtkDirectoryList*)({* id *}), (gboolean)({* property.value *}))"} },
    ["n-items"]     = {__type__="guint"    ,__default__ = "0"      },
  },
  parent = nil, 
};

---------------------  GtkEntryBuffer
Gtk418.GtkEntryBuffer = {
  class = "GtkEntryBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_entry_buffer_new((const char*)({* this.initial_chars.value *}), (int)({* this.n_initial_chars.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    delete_text   = {"guint"      , {"GtkEntryBuffer*", "guint", "guint"}, {"buffer", "position", "n_chars"} }, 
    deleted_text  = {"void"       , {"GtkEntryBuffer*", "guint", "guint"}, {"buffer", "position", "n_chars"} }, 
    get_length    = {"guint"      , {"GtkEntryBuffer*"}, {"buffer"} }, 
    get_text      = {"const char*", {"GtkEntryBuffer*", "gsize*"}, {"buffer", "n_bytes"} }, 
    insert_text   = {"guint"      , {"GtkEntryBuffer*", "guint", "const char*", "guint"}, {"buffer", "position", "chars", "n_chars"} }, 
    inserted_text = {"void"       , {"GtkEntryBuffer*", "guint", "const char*", "guint"}, {"buffer", "position", "chars", "n_chars"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['deleted-text']  = {ret_type = "void", params = {type = {"GtkEntryBuffer*", "guint", "guint"}, name ={"entrybuffer", "position", "n_chars"}} }, 
    ['inserted-text'] = {ret_type = "void", params = {type = {"GtkEntryBuffer*", "guint", "gchar*", "guint"}, name ={"entrybuffer", "position", "chars", "n_chars"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    length         = {__type__="guint"  ,__default__ = "0"     },
    ["max-length"] = {__type__="gint"   ,__default__ = "0"    , __gencode__ = {"gtk_entry_buffer_set_max_length((GtkEntryBuffer*)({* id *}), (int)({* property.value *}))"} },
    text           = {__type__="gchar*" ,__default__ = "\"\"" , __gencode__ = {"gtk_entry_buffer_set_text((GtkEntryBuffer*)({* id *}), (const char*)({* property.value *}), (int)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkEntryCompletion
Gtk418.GtkEntryCompletion = {
  class = "GtkEntryCompletion", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_entry_completion_new()", 
            params = { type = {}, name = {} } },
    new_with_area = { gencode = "gtk_entry_completion_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['cursor-on-match'] = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, name ={"entrycompletion", "model", "iter"}} }, 
    ['insert-prefix']   = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "gchar*"}, name ={"entrycompletion", "prefix"}} }, 
    ['match-selected']  = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, name ={"entrycompletion", "model", "iter"}} }, 
    ['no-matches']      = {ret_type = "void"    , params = {type = {"GtkEntryCompletion*"}, name ={"entrycompletion"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cell-area"]          = {__type__="GtkCellArea*"                         ,rwflags="rw" },
    ["inline-completion"]  = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_entry_completion_set_inline_completion((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["inline-selection"]   = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_entry_completion_set_inline_selection((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["minimum-key-length"] = {__type__="gint"          ,__default__ = "1"     , __gencode__ = {"gtk_entry_completion_set_minimum_key_length((GtkEntryCompletion*)({* id *}), (int)({* property.value *}))"} },
    model                  = {__type__="GtkTreeModel*"                        , __gencode__ = {"gtk_entry_completion_set_model((GtkEntryCompletion*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    ["popup-completion"]   = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_completion((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["popup-set-width"]    = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_set_width((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["popup-single-match"] = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_single_match((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["text-column"]        = {__type__="gint"          ,__default__ = "-1"    , __gencode__ = {"gtk_entry_completion_set_text_column((GtkEntryCompletion*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable, Gtk418.GtkCellLayout}, 
};

---------------------  GtkEventController
Gtk418.GtkEventController = {
  class = "GtkEventController", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    name                  = {__type__="gchar*"              ,__default__ = "NULL"                  , __gencode__ = {"gtk_event_controller_set_name((GtkEventController*)({* id *}), (const char*)({* property.value *}))"} },
    ["propagation-limit"] = {__type__="GtkPropagationLimit" ,__default__ = "GTK_LIMIT_SAME_NATIVE" , __gencode__ = {"gtk_event_controller_set_propagation_limit((GtkEventController*)({* id *}), (GtkPropagationLimit)({* property.value *}))"} },
    ["propagation-phase"] = {__type__="GtkPropagationPhase" ,__default__ = "GTK_PHASE_BUBBLE"      , __gencode__ = {"gtk_event_controller_set_propagation_phase((GtkEventController*)({* id *}), (GtkPropagationPhase)({* property.value *}))"} },
    widget                = {__type__="GtkWidget*"                                                  },
  },
  parent = nil, 
};

---------------------  GtkExpression
Gtk418.GtkExpression = {
  class = "GtkExpression", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkFileDialog
Gtk418.GtkFileDialog = {
  class = "GtkFileDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-label"]   = {__type__="gchar*"         ,__default__ = "NULL" , __gencode__ = {"gtk_file_dialog_set_accept_label((GtkFileDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["default-filter"] = {__type__="GtkFileFilter*"                       , __gencode__ = {"gtk_file_dialog_set_default_filter((GtkFileDialog*)({* id *}), (GtkFileFilter*)({* property.value *}))"} },
    filters            = {__type__="GListModel*"                          , __gencode__ = {"gtk_file_dialog_set_filters((GtkFileDialog*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["initial-file"]   = {__type__="GFile*"                               , __gencode__ = {"gtk_file_dialog_set_initial_file((GtkFileDialog*)({* id *}), (GFile*)({* property.value *}))"} },
    ["initial-folder"] = {__type__="GFile*"                               , __gencode__ = {"gtk_file_dialog_set_initial_folder((GtkFileDialog*)({* id *}), (GFile*)({* property.value *}))"} },
    ["initial-name"]   = {__type__="gchar*"         ,__default__ = "NULL" , __gencode__ = {"gtk_file_dialog_set_initial_name((GtkFileDialog*)({* id *}), (const char*)({* property.value *}))"} },
    modal              = {__type__="gboolean"       ,__default__ = "TRUE" , __gencode__ = {"gtk_file_dialog_set_modal((GtkFileDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    title              = {__type__="gchar*"         ,__default__ = "NULL" , __gencode__ = {"gtk_file_dialog_set_title((GtkFileDialog*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkFileLauncher
Gtk418.GtkFileLauncher = {
  class = "GtkFileLauncher", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_launcher_new((GFile*)({* this.file.value *}))", 
            params = { type = {"GFile*"}, 
                       name = {"file"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["always-ask"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_file_launcher_set_always_ask((GtkFileLauncher*)({* id *}), (gboolean)({* property.value *}))"} },
    file           = {__type__="GFile*"                          , __gencode__ = {"gtk_file_launcher_set_file((GtkFileLauncher*)({* id *}), (GFile*)({* property.value *}))"} },
    writable       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_file_launcher_set_writable((GtkFileLauncher*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkFilter
Gtk418.GtkFilter = {
  class = "GtkFilter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_strictness = {"GtkFilterMatch", {"GtkFilter*"}, {"self"} }, 
    match          = {"gboolean"      , {"GtkFilter*", "gpointer"}, {"self", "item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkFilter*", "GtkFilterChange"}, name ={"filter", "change"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkFilterListModel
Gtk418.GtkFilterListModel = {
  class = "GtkFilterListModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_filter_list_model_new((GListModel*)({* this.model.value *}), (GtkFilter*)({* this.filter.value *}))", 
            params = { type = {"GListModel*", "GtkFilter*"}, 
                       name = {"model", "filter"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filter        = {__type__="GtkFilter*"                         , __gencode__ = {"gtk_filter_list_model_set_filter((GtkFilterListModel*)({* id *}), (GtkFilter*)({* property.value *}))"} },
    incremental   = {__type__="gboolean"    ,__default__ = "FALSE" , __gencode__ = {"gtk_filter_list_model_set_incremental((GtkFilterListModel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["item-type"] = {__type__="GType"                               },
    model         = {__type__="GListModel*"                        , __gencode__ = {"gtk_filter_list_model_set_model((GtkFilterListModel*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"      },
    pending       = {__type__="guint"       ,__default__ = "0"      },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel}, 
};

---------------------  GtkFlattenListModel
Gtk418.GtkFlattenListModel = {
  class = "GtkFlattenListModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_flatten_list_model_new((GListModel*)({* this.model.value *}))", 
            params = { type = {"GListModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                           },
    model         = {__type__="GListModel*"                    , __gencode__ = {"gtk_flatten_list_model_set_model((GtkFlattenListModel*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"  },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel}, 
};

---------------------  GtkFontDialog
Gtk418.GtkFontDialog = {
  class = "GtkFontDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filter       = {__type__="GtkFilter*"                           , __gencode__ = {"gtk_font_dialog_set_filter((GtkFontDialog*)({* id *}), (GtkFilter*)({* property.value *}))"} },
    ["font-map"] = {__type__="PangoFontMap*"                        , __gencode__ = {"gtk_font_dialog_set_font_map((GtkFontDialog*)({* id *}), (PangoFontMap*)({* property.value *}))"} },
    language     = {__type__="PangoLanguage*"                       , __gencode__ = {"gtk_font_dialog_set_language((GtkFontDialog*)({* id *}), (PangoLanguage*)({* property.value *}))"} },
    modal        = {__type__="gboolean"       ,__default__ = "TRUE" , __gencode__ = {"gtk_font_dialog_set_modal((GtkFontDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    title        = {__type__="gchar*"         ,__default__ = "NULL" , __gencode__ = {"gtk_font_dialog_set_title((GtkFontDialog*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkIMContext
Gtk418.GtkIMContext = {
  class = "GtkIMContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_osk                   = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    activate_osk_with_event        = {"gboolean", {"GtkIMContext*", "GdkEvent*"}, {"context", "event"} }, 
    commit                         = {"void"    , {"GtkIMContext*", "const char*"}, {"context", "str"} }, 
    delete_surrounding             = {"gboolean", {"GtkIMContext*", "int", "int"}, {"context", "offset", "n_chars"} }, 
    filter_keypress                = {"gboolean", {"GtkIMContext*", "GdkEvent*"}, {"context", "event"} }, 
    focus_in                       = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    focus_out                      = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    get_preedit_string             = {"void"    , {"GtkIMContext*", "char**", "PangoAttrList**", "int*"}, {"context", "str", "attrs", "cursor_pos"} }, 
    get_surrounding                = {"gboolean", {"GtkIMContext*", "char**", "int*"}, {"context", "text", "cursor_index"} }, 
    get_surrounding_with_selection = {"gboolean", {"GtkIMContext*", "char**", "int*", "int*"}, {"context", "text", "cursor_index", "anchor_index"} }, 
    preedit_changed                = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    preedit_end                    = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    preedit_start                  = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    reset                          = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    retrieve_surrounding           = {"gboolean", {"GtkIMContext*"}, {"context"} }, 
    set_client_widget              = {"void"    , {"GtkIMContext*", "GtkWidget*"}, {"context", "widget"} }, 
    set_cursor_location            = {"void"    , {"GtkIMContext*", "GdkRectangle*"}, {"context", "area"} }, 
    set_surrounding                = {"void"    , {"GtkIMContext*", "const char*", "int", "int"}, {"context", "text", "len", "cursor_index"} }, 
    set_surrounding_with_selection = {"void"    , {"GtkIMContext*", "const char*", "int", "int", "int"}, {"context", "text", "len", "cursor_index", "anchor_index"} }, 
    set_use_preedit                = {"void"    , {"GtkIMContext*", "gboolean"}, {"context", "use_preedit"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    commit                   = {ret_type = "void"    , params = {type = {"GtkIMContext*", "const char*"}, name ={"context", "str"}} }, 
    ['delete-surrounding']   = {ret_type = "gboolean", params = {type = {"GtkIMContext*", "gint", "gint"}, name ={"imcontext", "offset", "n_chars"}} }, 
    ['preedit-changed']      = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['preedit-end']          = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['preedit-start']        = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['retrieve-surrounding'] = {ret_type = "gboolean", params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["input-hints"]   = {__type__="GtkInputHints"                                                ,rwflags="rw" },
    ["input-purpose"] = {__type__="GtkInputPurpose" ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkIconPaintable
Gtk418.GtkIconPaintable = {
  class = "GtkIconPaintable", 
  constructor = { 
    -- 名称[- ==> _], 
    new_for_file = { gencode = "gtk_icon_paintable_new_for_file((GFile*)({* this.file.value *}), (int)({* this.size.value *}), (int)({* this.scale.value *}))", 
            params = { type = {"GFile*"}, 
                       name = {"file"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    file            = {__type__="GFile*"                          ,rwflags="rw" },
    ["icon-name"]   = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
    ["is-symbolic"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk418.GtkSymbolicPaintable}, 
};

---------------------  GtkIconTheme
Gtk418.GtkIconTheme = {
  class = "GtkIconTheme", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_theme_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkIconTheme*"}, name ={"icontheme"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    display           = {__type__="GdkDisplay*"                       ,rwflags="rw" },
    ["icon-names"]    = {__type__="GStrv"                              },
    ["resource-path"] = {__type__="GStrv"                             , __gencode__ = {"gtk_icon_theme_set_resource_path((GtkIconTheme*)({* id *}), (const char* const*)({* property.value *}))"} },
    ["search-path"]   = {__type__="GStrv"                             , __gencode__ = {"gtk_icon_theme_set_search_path((GtkIconTheme*)({* id *}), (const char* const*)({* property.value *}))"} },
    ["theme-name"]    = {__type__="gchar*"      ,__default__ = "NULL" , __gencode__ = {"gtk_icon_theme_set_theme_name((GtkIconTheme*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkLayoutChild
Gtk418.GtkLayoutChild = {
  class = "GtkLayoutChild", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["child-widget"]   = {__type__="GtkWidget*"        ,rwflags="rw" },
    ["layout-manager"] = {__type__="GtkLayoutManager*" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkLayoutManager
Gtk418.GtkLayoutManager = {
  class = "GtkLayoutManager", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    allocate            = {"void"              , {"GtkLayoutManager*", "GtkWidget*", "int", "int", "int"}, {"manager", "widget", "width", "height", "baseline"} }, 
    create_layout_child = {"GtkLayoutChild*"   , {"GtkLayoutManager*", "GtkWidget*", "GtkWidget*"}, {"manager", "widget", "for_child"} }, 
    get_request_mode    = {"GtkSizeRequestMode", {"GtkLayoutManager*", "GtkWidget*"}, {"manager", "widget"} }, 
    measure             = {"void"              , {"GtkLayoutManager*", "GtkWidget*", "GtkOrientation", "int", "int*", "int*", "int*", "int*"}, {"manager", "widget", "orientation", "for_size", "minimum", "natural", "minimum_baseline", "natural_baseline"} }, 
    root                = {"void"              , {"GtkLayoutManager*"}, {"manager"} }, 
    unroot              = {"void"              , {"GtkLayoutManager*"}, {"manager"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkListHeader
Gtk418.GtkListHeader = {
  class = "GtkListHeader", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child       = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_list_header_set_child((GtkListHeader*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["end"]     = {__type__="guint"      ,__default__ = "4294967295"  },
    item        = {__type__="GObject*"                                },
    ["n-items"] = {__type__="guint"      ,__default__ = "0"           },
    start       = {__type__="guint"      ,__default__ = "4294967295"  },
  },
  parent = nil, 
};

---------------------  GtkListItem
Gtk418.GtkListItem = {
  class = "GtkListItem", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accessible-description"] = {__type__="gchar*"     ,__default__ = "NULL"       , __gencode__ = {"gtk_list_item_set_accessible_description((GtkListItem*)({* id *}), (const char*)({* property.value *}))"} },
    ["accessible-label"]       = {__type__="gchar*"     ,__default__ = "NULL"       , __gencode__ = {"gtk_list_item_set_accessible_label((GtkListItem*)({* id *}), (const char*)({* property.value *}))"} },
    activatable                = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_list_item_set_activatable((GtkListItem*)({* id *}), (gboolean)({* property.value *}))"} },
    child                      = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_list_item_set_child((GtkListItem*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    focusable                  = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_list_item_set_focusable((GtkListItem*)({* id *}), (gboolean)({* property.value *}))"} },
    item                       = {__type__="GObject*"                                },
    position                   = {__type__="guint"      ,__default__ = "4294967295"  },
    selectable                 = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_list_item_set_selectable((GtkListItem*)({* id *}), (gboolean)({* property.value *}))"} },
    selected                   = {__type__="gboolean"   ,__default__ = "FALSE"       },
  },
  parent = nil, 
};

---------------------  GtkListItemFactory
Gtk418.GtkListItemFactory = {
  class = "GtkListItemFactory", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkListStore
Gtk418.GtkListStore = {
  class = "GtkListStore", 
  constructor = { 
    -- 名称[- ==> _], 
    new  = { gencode = "gtk_list_store_new((int)({* this.n_columns.value *}), 0)", 
            params = { type = {}, name = {} } },
    newv = { gencode = "gtk_list_store_newv((int)({* this.n_columns.value *}), (GType*)({* this.types.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable, Gtk418.GtkTreeDragDest, Gtk418.GtkTreeDragSource, Gtk418.GtkTreeModel, Gtk418.GtkTreeSortable}, 
};

---------------------  GtkMapListModel
Gtk418.GtkMapListModel = {
  class = "GtkMapListModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_map_list_model_new((GListModel*)({* this.model.value *}), (GtkMapListModelMapFunc)({* this.map_func.value *}), (gpointer)({* this.user_data.value *}), (GDestroyNotify)({* this.user_destroy.value *}))", 
            params = { type = {"GListModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["has-map"]   = {__type__="gboolean"    ,__default__ = "FALSE"  },
    ["item-type"] = {__type__="GType"                               },
    model         = {__type__="GListModel*"                        , __gencode__ = {"gtk_map_list_model_set_model((GtkMapListModel*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"      },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel}, 
};

---------------------  GtkMediaStream
Gtk418.GtkMediaStream = {
  class = "GtkMediaStream", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    pause        = {"void"    , {"GtkMediaStream*"}, {"self"} }, 
    play         = {"gboolean", {"GtkMediaStream*"}, {"self"} }, 
    realize      = {"void"    , {"GtkMediaStream*", "GdkSurface*"}, {"self", "surface"} }, 
    seek         = {"void"    , {"GtkMediaStream*", "gint64"}, {"self", "timestamp"} }, 
    unrealize    = {"void"    , {"GtkMediaStream*", "GdkSurface*"}, {"self", "surface"} }, 
    update_audio = {"void"    , {"GtkMediaStream*", "gboolean", "double"}, {"self", "muted", "volume"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    duration      = {__type__="gint64"   ,__default__ = "0"      },
    ended         = {__type__="gboolean" ,__default__ = "FALSE"  },
    error         = {__type__="GError*"                          },
    ["has-audio"] = {__type__="gboolean" ,__default__ = "FALSE"  },
    ["has-video"] = {__type__="gboolean" ,__default__ = "FALSE"  },
    loop          = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_media_stream_set_loop((GtkMediaStream*)({* id *}), (gboolean)({* property.value *}))"} },
    muted         = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_media_stream_set_muted((GtkMediaStream*)({* id *}), (gboolean)({* property.value *}))"} },
    playing       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_media_stream_set_playing((GtkMediaStream*)({* id *}), (gboolean)({* property.value *}))"} },
    prepared      = {__type__="gboolean" ,__default__ = "FALSE"  },
    seekable      = {__type__="gboolean" ,__default__ = "TRUE"   },
    seeking       = {__type__="gboolean" ,__default__ = "FALSE"  },
    timestamp     = {__type__="gint64"   ,__default__ = "0"      },
    volume        = {__type__="gdouble"  ,__default__ = "1"     , __gencode__ = {"gtk_media_stream_set_volume((GtkMediaStream*)({* id *}), (double)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkMountOperation
Gtk418.GtkMountOperation = {
  class = "GtkMountOperation", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_mount_operation_new((GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"GtkWindow*"}, 
                       name = {"parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    display        = {__type__="GdkDisplay*"                        , __gencode__ = {"gtk_mount_operation_set_display((GtkMountOperation*)({* id *}), (GdkDisplay*)({* property.value *}))"} },
    ["is-showing"] = {__type__="gboolean"    ,__default__ = "FALSE"  },
    parent         = {__type__="GtkWindow*"                         , __gencode__ = {"gtk_mount_operation_set_parent((GtkMountOperation*)({* id *}), (GtkWindow*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkMultiSelection
Gtk418.GtkMultiSelection = {
  class = "GtkMultiSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_multi_selection_new((GListModel*)({* this.model.value *}))", 
            params = { type = {"GListModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                           },
    model         = {__type__="GListModel*"                    , __gencode__ = {"gtk_multi_selection_set_model((GtkMultiSelection*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"  },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel, Gtk418.GtkSelectionModel}, 
};

---------------------  GtkNativeDialog
Gtk418.GtkNativeDialog = {
  class = "GtkNativeDialog", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    hide     = {"void", {"GtkNativeDialog*"}, {"self"} }, 
    response = {"void", {"GtkNativeDialog*", "int"}, {"self", "response_id"} }, 
    show     = {"void", {"GtkNativeDialog*"}, {"self"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    response = {ret_type = "void", params = {type = {"GtkNativeDialog*", "int"}, name ={"self", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    modal             = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_native_dialog_set_modal((GtkNativeDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    title             = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_native_dialog_set_title((GtkNativeDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["transient-for"] = {__type__="GtkWindow*"                        , __gencode__ = {"gtk_native_dialog_set_transient_for((GtkNativeDialog*)({* id *}), (GtkWindow*)({* property.value *}))"},__construct__= 1 },
    visible           = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkNoSelection
Gtk418.GtkNoSelection = {
  class = "GtkNoSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_no_selection_new((GListModel*)({* this.model.value *}))", 
            params = { type = {"GListModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                           },
    model         = {__type__="GListModel*"                    , __gencode__ = {"gtk_no_selection_set_model((GtkNoSelection*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"  },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel, Gtk418.GtkSelectionModel}, 
};

---------------------  GtkNotebookPage
Gtk418.GtkNotebookPage = {
  class = "GtkNotebookPage", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child          = {__type__="GtkWidget*"                        ,rwflags="rw" },
    detachable     = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    menu           = {__type__="GtkWidget*"                        ,rwflags="rw" },
    ["menu-label"] = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
    position       = {__type__="gint"       ,__default__ = "0"     ,rwflags="rw" },
    reorderable    = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    tab            = {__type__="GtkWidget*"                        ,rwflags="rw" },
    ["tab-expand"] = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    ["tab-fill"]   = {__type__="gboolean"   ,__default__ = "TRUE"  ,rwflags="rw" },
    ["tab-label"]  = {__type__="gchar*"     ,__default__ = "NULL"  ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkPageSetup
Gtk418.GtkPageSetup = {
  class = "GtkPageSetup", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_page_setup_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_page_setup_new_from_file((const char*)({* this.file_name.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gvariant = { gencode = "gtk_page_setup_new_from_gvariant((GVariant*)({* this.variant.value *}))", 
            params = { type = {}, name = {} } },
    new_from_key_file = { gencode = "gtk_page_setup_new_from_key_file((GKeyFile*)({* this.key_file.value *}), (const char*)({* this.group_name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkParamSpecExpression
Gtk418.GtkParamSpecExpression = {
  class = "GtkParamSpecExpression", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrintContext
Gtk418.GtkPrintContext = {
  class = "GtkPrintContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrintDialog
Gtk418.GtkPrintDialog = {
  class = "GtkPrintDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-label"]   = {__type__="gchar*"            ,__default__ = "NULL" , __gencode__ = {"gtk_print_dialog_set_accept_label((GtkPrintDialog*)({* id *}), (const char*)({* property.value *}))"} },
    modal              = {__type__="gboolean"          ,__default__ = "TRUE" , __gencode__ = {"gtk_print_dialog_set_modal((GtkPrintDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    ["page-setup"]     = {__type__="GtkPageSetup*"                           , __gencode__ = {"gtk_print_dialog_set_page_setup((GtkPrintDialog*)({* id *}), (GtkPageSetup*)({* property.value *}))"} },
    ["print-settings"] = {__type__="GtkPrintSettings*"                       , __gencode__ = {"gtk_print_dialog_set_print_settings((GtkPrintDialog*)({* id *}), (GtkPrintSettings*)({* property.value *}))"} },
    title              = {__type__="gchar*"            ,__default__ = "NULL" , __gencode__ = {"gtk_print_dialog_set_title((GtkPrintDialog*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPrintJob
Gtk418.GtkPrintJob = {
  class = "GtkPrintJob", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_job_new((const char*)({* this.title.value *}), (GtkPrinter*)({* this.printer.value *}), (GtkPrintSettings*)({* this.settings.value *}), (GtkPageSetup*)({* this['page-setup'].value *}))", 
            params = { type = {"const char*", "GtkPrinter*", "GtkPrintSettings*", "GtkPageSetup*"}, 
                       name = {"title", "printer", "settings", "page-setup"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['status-changed'] = {ret_type = "void", params = {type = {"GtkPrintJob*"}, name ={"printjob"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["page-setup"]         = {__type__="GtkPageSetup*"                            ,rwflags="rw" },
    printer                = {__type__="GtkPrinter*"                              ,rwflags="rw" },
    settings               = {__type__="GtkPrintSettings*"                        ,rwflags="rw" },
    title                  = {__type__="gchar*"            ,__default__ = "NULL"  ,rwflags="rw" },
    ["track-print-status"] = {__type__="gboolean"          ,__default__ = "FALSE" , __gencode__ = {"gtk_print_job_set_track_print_status((GtkPrintJob*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPrintOperation
Gtk418.GtkPrintOperation = {
  class = "GtkPrintOperation", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_operation_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    begin_print          = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    create_custom_widget = {"GtkWidget*", {"GtkPrintOperation*"}, {"operation"} }, 
    custom_widget_apply  = {"void"      , {"GtkPrintOperation*", "GtkWidget*"}, {"operation", "widget"} }, 
    done                 = {"void"      , {"GtkPrintOperation*", "GtkPrintOperationResult"}, {"operation", "result"} }, 
    draw_page            = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*", "int"}, {"operation", "context", "page_nr"} }, 
    end_print            = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    paginate             = {"gboolean"  , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    preview              = {"gboolean"  , {"GtkPrintOperation*", "GtkPrintOperationPreview*", "GtkPrintContext*", "GtkWindow*"}, {"operation", "preview", "context", "parent"} }, 
    request_page_setup   = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*", "int", "GtkPageSetup*"}, {"operation", "context", "page_nr", "setup"} }, 
    status_changed       = {"void"      , {"GtkPrintOperation*"}, {"operation"} }, 
    update_custom_widget = {"void"      , {"GtkPrintOperation*", "GtkWidget*", "GtkPageSetup*", "GtkPrintSettings*"}, {"operation", "widget", "setup", "settings"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['begin-print']          = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"printoperation", "context"}} }, 
    ['create-custom-widget'] = {ret_type = "GObject*", params = {type = {"GtkPrintOperation*"}, name ={"printoperation"}} }, 
    ['custom-widget-apply']  = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkWidget*"}, name ={"printoperation", "widget"}} }, 
    done                     = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintOperationResult"}, name ={"operation", "result"}} }, 
    ['draw-page']            = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*", "gint"}, name ={"printoperation", "context", "page_nr"}} }, 
    ['end-print']            = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"printoperation", "context"}} }, 
    paginate                 = {ret_type = "gboolean", params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"operation", "context"}} }, 
    preview                  = {ret_type = "gboolean", params = {type = {"GtkPrintOperation*", "GtkPrintOperationPreview*", "GtkPrintContext*", "GtkWindow*"}, name ={"operation", "preview", "context", "parent"}} }, 
    ['request-page-setup']   = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*", "gint", "GtkPageSetup*"}, name ={"printoperation", "context", "page_nr", "setup"}} }, 
    ['status-changed']       = {ret_type = "void"    , params = {type = {"GtkPrintOperation*"}, name ={"printoperation"}} }, 
    ['update-custom-widget'] = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkWidget*", "GtkPageSetup*", "GtkPrintSettings*"}, name ={"printoperation", "widget", "setup", "settings"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["allow-async"]        = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_allow_async((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["current-page"]       = {__type__="gint"              ,__default__ = "-1"                       , __gencode__ = {"gtk_print_operation_set_current_page((GtkPrintOperation*)({* id *}), (int)({* property.value *}))"} },
    ["custom-tab-label"]   = {__type__="gchar*"            ,__default__ = "NULL"                     , __gencode__ = {"gtk_print_operation_set_custom_tab_label((GtkPrintOperation*)({* id *}), (const char*)({* property.value *}))"} },
    ["default-page-setup"] = {__type__="GtkPageSetup*"                                               , __gencode__ = {"gtk_print_operation_set_default_page_setup((GtkPrintOperation*)({* id *}), (GtkPageSetup*)({* property.value *}))"} },
    ["embed-page-setup"]   = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_embed_page_setup((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["export-filename"]    = {__type__="gchar*"            ,__default__ = "NULL"                     , __gencode__ = {"gtk_print_operation_set_export_filename((GtkPrintOperation*)({* id *}), (const char*)({* property.value *}))"} },
    ["has-selection"]      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_has_selection((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["job-name"]           = {__type__="gchar*"            ,__default__ = "\"\""                     , __gencode__ = {"gtk_print_operation_set_job_name((GtkPrintOperation*)({* id *}), (const char*)({* property.value *}))"} },
    ["n-pages"]            = {__type__="gint"              ,__default__ = "-1"                       , __gencode__ = {"gtk_print_operation_set_n_pages((GtkPrintOperation*)({* id *}), (int)({* property.value *}))"} },
    ["n-pages-to-print"]   = {__type__="gint"              ,__default__ = "-1"                        },
    ["print-settings"]     = {__type__="GtkPrintSettings*"                                           , __gencode__ = {"gtk_print_operation_set_print_settings((GtkPrintOperation*)({* id *}), (GtkPrintSettings*)({* property.value *}))"} },
    ["show-progress"]      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_show_progress((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    status                 = {__type__="GtkPrintStatus"    ,__default__ = "GTK_PRINT_STATUS_INITIAL"  },
    ["status-string"]      = {__type__="gchar*"            ,__default__ = "\"\""                      },
    ["support-selection"]  = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_support_selection((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["track-print-status"] = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_track_print_status((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    unit                   = {__type__="GtkUnit"           ,__default__ = "GTK_UNIT_NONE"            , __gencode__ = {"gtk_print_operation_set_unit((GtkPrintOperation*)({* id *}), (GtkUnit)({* property.value *}))"} },
    ["use-full-page"]      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_use_full_page((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkPrintOperationPreview}, 
};

---------------------  GtkPrintSettings
Gtk418.GtkPrintSettings = {
  class = "GtkPrintSettings", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_print_settings_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_print_settings_new_from_file((const char*)({* this.file_name.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gvariant = { gencode = "gtk_print_settings_new_from_gvariant((GVariant*)({* this.variant.value *}))", 
            params = { type = {}, name = {} } },
    new_from_key_file = { gencode = "gtk_print_settings_new_from_key_file((GKeyFile*)({* this.key_file.value *}), (const char*)({* this.group_name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrinter
Gtk418.GtkPrinter = {
  class = "GtkPrinter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_printer_new((const char*)({* this.name.value *}), (GtkPrintBackend*)({* this.backend.value *}), (gboolean)({* this.virtual_.value *}))", 
            params = { type = {"const char*", "GtkPrintBackend*"}, 
                       name = {"name", "backend"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['details-acquired'] = {ret_type = "void", params = {type = {"GtkPrinter*", "gboolean"}, name ={"printer", "success"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accepting-jobs"] = {__type__="gboolean"         ,__default__ = "TRUE"         },
    ["accepts-pdf"]    = {__type__="gboolean"         ,__default__ = "FALSE"       ,rwflags="rw" },
    ["accepts-ps"]     = {__type__="gboolean"         ,__default__ = "TRUE"        ,rwflags="rw" },
    backend            = {__type__="GtkPrintBackend*"                              ,rwflags="rw" },
    ["icon-name"]      = {__type__="gchar*"           ,__default__ = "\"printer\""  },
    ["is-virtual"]     = {__type__="gboolean"         ,__default__ = "FALSE"       ,rwflags="rw" },
    ["job-count"]      = {__type__="gint"             ,__default__ = "0"            },
    location           = {__type__="gchar*"           ,__default__ = "\"\""         },
    name               = {__type__="gchar*"           ,__default__ = "\"\""        ,rwflags="rw" },
    paused             = {__type__="gboolean"         ,__default__ = "FALSE"        },
    ["state-message"]  = {__type__="gchar*"           ,__default__ = "\"\""         },
  },
  parent = nil, 
};

---------------------  GtkRecentManager
Gtk418.GtkRecentManager = {
  class = "GtkRecentManager", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_recent_manager_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkRecentManager*"}, {"manager"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkRecentManager*"}, name ={"manager"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filename = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    size     = {__type__="gint"   ,__default__ = "0"     },
  },
  parent = nil, 
};

---------------------  GtkSelectionFilterModel
Gtk418.GtkSelectionFilterModel = {
  class = "GtkSelectionFilterModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_selection_filter_model_new((GtkSelectionModel*)({* this.model.value *}))", 
            params = { type = {"GtkSelectionModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                                  },
    model         = {__type__="GtkSelectionModel*"                    , __gencode__ = {"gtk_selection_filter_model_set_model((GtkSelectionFilterModel*)({* id *}), (GtkSelectionModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"              ,__default__ = "0"  },
  },
  parent = nil, 
};

---------------------  GtkSettings
Gtk418.GtkSettings = {
  class = "GtkSettings", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["gtk-alternative-button-order"]      = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-alternative-sort-arrows"]       = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-application-prefer-dark-theme"] = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-cursor-aspect-ratio"]           = {__type__="gdouble"          ,__default__ = "0.04"                                                          ,rwflags="rw" },
    ["gtk-cursor-blink"]                  = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-cursor-blink-time"]             = {__type__="gint"             ,__default__ = "1200"                                                          ,rwflags="rw" },
    ["gtk-cursor-blink-timeout"]          = {__type__="gint"             ,__default__ = "10"                                                            ,rwflags="rw" },
    ["gtk-cursor-theme-name"]             = {__type__="gchar*"           ,__default__ = "NULL"                                                          ,rwflags="rw" },
    ["gtk-cursor-theme-size"]             = {__type__="gint"             ,__default__ = "0"                                                             ,rwflags="rw" },
    ["gtk-decoration-layout"]             = {__type__="gchar*"           ,__default__ = "\"menu:minimize,maximize,close\""                              ,rwflags="rw" },
    ["gtk-dialogs-use-header"]            = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-dnd-drag-threshold"]            = {__type__="gint"             ,__default__ = "8"                                                             ,rwflags="rw" },
    ["gtk-double-click-distance"]         = {__type__="gint"             ,__default__ = "5"                                                             ,rwflags="rw" },
    ["gtk-double-click-time"]             = {__type__="gint"             ,__default__ = "400"                                                           ,rwflags="rw" },
    ["gtk-enable-accels"]                 = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-enable-animations"]             = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-enable-event-sounds"]           = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-enable-input-feedback-sounds"]  = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-enable-primary-paste"]          = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-entry-password-hint-timeout"]   = {__type__="guint"            ,__default__ = "0"                                                             ,rwflags="rw" },
    ["gtk-entry-select-on-focus"]         = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-error-bell"]                    = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-font-name"]                     = {__type__="gchar*"           ,__default__ = "\"Sans 10\""                                                   ,rwflags="rw" },
    ["gtk-font-rendering"]                = {__type__="GtkFontRendering" ,__default__ = "GTK_FONT_RENDERING_AUTOMATIC"                                  ,rwflags="rw" },
    ["gtk-fontconfig-timestamp"]          = {__type__="guint"            ,__default__ = "0"                                                             ,rwflags="rw" },
    ["gtk-hint-font-metrics"]             = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-icon-theme-name"]               = {__type__="gchar*"           ,__default__ = "\"Adwaita\""                                                   ,rwflags="rw" },
    ["gtk-im-module"]                     = {__type__="gchar*"           ,__default__ = "NULL"                                                          ,rwflags="rw" },
    ["gtk-keynav-use-caret"]              = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-label-select-on-focus"]         = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-long-press-time"]               = {__type__="guint"            ,__default__ = "500"                                                           ,rwflags="rw" },
    ["gtk-overlay-scrolling"]             = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-primary-button-warps-slider"]   = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-print-backends"]                = {__type__="gchar*"           ,__default__ = "\"cups,file\""                                                 ,rwflags="rw" },
    ["gtk-print-preview-command"]         = {__type__="gchar*"           ,__default__ = "\"evince --unlink-tempfile --preview --print-settings %s %f\"" ,rwflags="rw" },
    ["gtk-recent-files-enabled"]          = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-recent-files-max-age"]          = {__type__="gint"             ,__default__ = "30"                                                            ,rwflags="rw" },
    ["gtk-shell-shows-app-menu"]          = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-shell-shows-desktop"]           = {__type__="gboolean"         ,__default__ = "TRUE"                                                          ,rwflags="rw" },
    ["gtk-shell-shows-menubar"]           = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-show-status-shapes"]            = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-sound-theme-name"]              = {__type__="gchar*"           ,__default__ = "\"freedesktop\""                                               ,rwflags="rw" },
    ["gtk-split-cursor"]                  = {__type__="gboolean"         ,__default__ = "FALSE"                                                         ,rwflags="rw" },
    ["gtk-theme-name"]                    = {__type__="gchar*"           ,__default__ = "\"Default\""                                                   ,rwflags="rw" },
    ["gtk-titlebar-double-click"]         = {__type__="gchar*"           ,__default__ = "\"toggle-maximize\""                                           ,rwflags="rw" },
    ["gtk-titlebar-middle-click"]         = {__type__="gchar*"           ,__default__ = "\"none\""                                                      ,rwflags="rw" },
    ["gtk-titlebar-right-click"]          = {__type__="gchar*"           ,__default__ = "\"menu\""                                                      ,rwflags="rw" },
    ["gtk-xft-antialias"]                 = {__type__="gint"             ,__default__ = "-1"                                                            ,rwflags="rw" },
    ["gtk-xft-dpi"]                       = {__type__="gint"             ,__default__ = "-1"                                                            ,rwflags="rw" },
    ["gtk-xft-hinting"]                   = {__type__="gint"             ,__default__ = "-1"                                                            ,rwflags="rw" },
    ["gtk-xft-hintstyle"]                 = {__type__="gchar*"           ,__default__ = "NULL"                                                          ,rwflags="rw" },
    ["gtk-xft-rgba"]                      = {__type__="gchar*"           ,__default__ = "NULL"                                                          ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk418.GtkStyleProvider}, 
};

---------------------  GtkShortcut
Gtk418.GtkShortcut = {
  class = "GtkShortcut", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_shortcut_new((GtkShortcutTrigger*)({* this.trigger.value *}), (GtkShortcutAction*)({* this.action.value *}))", 
            params = { type = {"GtkShortcutTrigger*", "GtkShortcutAction*"}, 
                       name = {"trigger", "action"} } },
    new_with_arguments = { gencode = "gtk_shortcut_new_with_arguments((GtkShortcutTrigger*)({* this.trigger.value *}), (GtkShortcutAction*)({* this.action.value *}), (const char*)({* this.format_string.value *}), 0)", 
            params = { type = {"GtkShortcutTrigger*", "GtkShortcutAction*"}, 
                       name = {"trigger", "action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    action    = {__type__="GtkShortcutAction*"                        , __gencode__ = {"gtk_shortcut_set_action((GtkShortcut*)({* id *}), (GtkShortcutAction*)({* property.value *}))"} },
    arguments = {__type__="GVariant*"           ,__default__ = "NULL" , __gencode__ = {"gtk_shortcut_set_arguments((GtkShortcut*)({* id *}), (GVariant*)({* property.value *}))"} },
    trigger   = {__type__="GtkShortcutTrigger*"                       , __gencode__ = {"gtk_shortcut_set_trigger((GtkShortcut*)({* id *}), (GtkShortcutTrigger*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkShortcutAction
Gtk418.GtkShortcutAction = {
  class = "GtkShortcutAction", 
  constructor = { 
    -- 名称[- ==> _], 
    parse_string = { gencode = "gtk_shortcut_action_parse_string((const char*)({* this.string.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkShortcutTrigger
Gtk418.GtkShortcutTrigger = {
  class = "GtkShortcutTrigger", 
  constructor = { 
    -- 名称[- ==> _], 
    parse_string = { gencode = "gtk_shortcut_trigger_parse_string((const char*)({* this.string.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkSingleSelection
Gtk418.GtkSingleSelection = {
  class = "GtkSingleSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_single_selection_new((GListModel*)({* this.model.value *}))", 
            params = { type = {"GListModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    autoselect        = {__type__="gboolean"    ,__default__ = "TRUE"       , __gencode__ = {"gtk_single_selection_set_autoselect((GtkSingleSelection*)({* id *}), (gboolean)({* property.value *}))"} },
    ["can-unselect"]  = {__type__="gboolean"    ,__default__ = "FALSE"      , __gencode__ = {"gtk_single_selection_set_can_unselect((GtkSingleSelection*)({* id *}), (gboolean)({* property.value *}))"} },
    ["item-type"]     = {__type__="GType"                                    },
    model             = {__type__="GListModel*"                             , __gencode__ = {"gtk_single_selection_set_model((GtkSingleSelection*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]       = {__type__="guint"       ,__default__ = "0"           },
    selected          = {__type__="guint"       ,__default__ = "4294967295" , __gencode__ = {"gtk_single_selection_set_selected((GtkSingleSelection*)({* id *}), (guint)({* property.value *}))"} },
    ["selected-item"] = {__type__="GObject*"                                 },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel, Gtk418.GtkSelectionModel}, 
};

---------------------  GtkSizeGroup
Gtk418.GtkSizeGroup = {
  class = "GtkSizeGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_size_group_new((GtkSizeGroupMode)({* this.mode.value *}))", 
            params = { type = {"GtkSizeGroupMode"}, 
                       name = {"mode"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    mode = {__type__="GtkSizeGroupMode" ,__default__ = "GTK_SIZE_GROUP_HORIZONTAL" , __gencode__ = {"gtk_size_group_set_mode((GtkSizeGroup*)({* id *}), (GtkSizeGroupMode)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkSliceListModel
Gtk418.GtkSliceListModel = {
  class = "GtkSliceListModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_slice_list_model_new((GListModel*)({* this.model.value *}), (guint)({* this.offset.value *}), (guint)({* this.size.value *}))", 
            params = { type = {"GListModel*", "guint", "guint"}, 
                       name = {"model", "offset", "size"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                            },
    model         = {__type__="GListModel*"                     , __gencode__ = {"gtk_slice_list_model_set_model((GtkSliceListModel*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"   },
    offset        = {__type__="guint"       ,__default__ = "0"  , __gencode__ = {"gtk_slice_list_model_set_offset((GtkSliceListModel*)({* id *}), (guint)({* property.value *}))"} },
    size          = {__type__="guint"       ,__default__ = "10" , __gencode__ = {"gtk_slice_list_model_set_size((GtkSliceListModel*)({* id *}), (guint)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel}, 
};

---------------------  GtkSnapshot
Gtk418.GtkSnapshot = {
  class = "GtkSnapshot", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_snapshot_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkSortListModel
Gtk418.GtkSortListModel = {
  class = "GtkSortListModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_sort_list_model_new((GListModel*)({* this.model.value *}), (GtkSorter*)({* this.sorter.value *}))", 
            params = { type = {"GListModel*", "GtkSorter*"}, 
                       name = {"model", "sorter"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    incremental        = {__type__="gboolean"    ,__default__ = "FALSE" , __gencode__ = {"gtk_sort_list_model_set_incremental((GtkSortListModel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["item-type"]      = {__type__="GType"                               },
    model              = {__type__="GListModel*"                        , __gencode__ = {"gtk_sort_list_model_set_model((GtkSortListModel*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["n-items"]        = {__type__="guint"       ,__default__ = "0"      },
    pending            = {__type__="guint"       ,__default__ = "0"      },
    ["section-sorter"] = {__type__="GtkSorter*"                         , __gencode__ = {"gtk_sort_list_model_set_section_sorter((GtkSortListModel*)({* id *}), (GtkSorter*)({* property.value *}))"} },
    sorter             = {__type__="GtkSorter*"                         , __gencode__ = {"gtk_sort_list_model_set_sorter((GtkSortListModel*)({* id *}), (GtkSorter*)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkSectionModel}, 
};

---------------------  GtkSorter
Gtk418.GtkSorter = {
  class = "GtkSorter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    compare   = {"GtkOrdering"   , {"GtkSorter*", "gpointer", "gpointer"}, {"self", "item1", "item2"} }, 
    get_order = {"GtkSorterOrder", {"GtkSorter*"}, {"self"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkSorter*", "GtkSorterChange"}, name ={"sorter", "change"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkStackPage
Gtk418.GtkStackPage = {
  class = "GtkStackPage", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child               = {__type__="GtkWidget*"                        ,rwflags="rw" },
    ["icon-name"]       = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_stack_page_set_icon_name((GtkStackPage*)({* id *}), (const char*)({* property.value *}))"} },
    name                = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_stack_page_set_name((GtkStackPage*)({* id *}), (const char*)({* property.value *}))"} },
    ["needs-attention"] = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_stack_page_set_needs_attention((GtkStackPage*)({* id *}), (gboolean)({* property.value *}))"} },
    title               = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_stack_page_set_title((GtkStackPage*)({* id *}), (const char*)({* property.value *}))"} },
    ["use-underline"]   = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_stack_page_set_use_underline((GtkStackPage*)({* id *}), (gboolean)({* property.value *}))"} },
    visible             = {__type__="gboolean"   ,__default__ = "TRUE"  , __gencode__ = {"gtk_stack_page_set_visible((GtkStackPage*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk418.GtkAccessible}, 
};

---------------------  GtkStringList
Gtk418.GtkStringList = {
  class = "GtkStringList", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_string_list_new((const char* const*)({* this.strings.value *}))", 
            params = { type = {"const char* const*"}, 
                       name = {"strings"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                     },
    ["n-items"]   = {__type__="guint" ,__default__ = "0"  },
    strings       = {__type__="GStrv"                    ,rwflags="w" },
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkStringObject
Gtk418.GtkStringObject = {
  class = "GtkStringObject", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_string_object_new((const char*)({* this.string.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"string"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    string = {__type__="gchar*" ,__default__ = "NULL"  },
  },
  parent = nil, 
};

---------------------  GtkStyleContext
Gtk418.GtkStyleContext = {
  class = "GtkStyleContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkStyleContext*"}, {"context"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    display = {__type__="GdkDisplay*" , __gencode__ = {"gtk_style_context_set_display((GtkStyleContext*)({* id *}), (GdkDisplay*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkTextBuffer
Gtk418.GtkTextBuffer = {
  class = "GtkTextBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_buffer_new((GtkTextTagTable*)({* this.table.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    apply_tag           = {"void", {"GtkTextBuffer*", "GtkTextTag*", "const GtkTextIter*", "const GtkTextIter*"}, {"buffer", "tag", "start", "end"} }, 
    begin_user_action   = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    changed             = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    delete_range        = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GtkTextIter*"}, {"buffer", "start", "end"} }, 
    end_user_action     = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    insert_child_anchor = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GtkTextChildAnchor*"}, {"buffer", "iter", "anchor"} }, 
    insert_paintable    = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GdkPaintable*"}, {"buffer", "iter", "paintable"} }, 
    insert_text         = {"void", {"GtkTextBuffer*", "GtkTextIter*", "const char*", "int"}, {"buffer", "pos", "new_text", "new_text_length"} }, 
    mark_deleted        = {"void", {"GtkTextBuffer*", "GtkTextMark*"}, {"buffer", "mark"} }, 
    mark_set            = {"void", {"GtkTextBuffer*", "const GtkTextIter*", "GtkTextMark*"}, {"buffer", "location", "mark"} }, 
    modified_changed    = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    paste_done          = {"void", {"GtkTextBuffer*", "GdkClipboard*"}, {"buffer", "clipboard"} }, 
    redo                = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    remove_tag          = {"void", {"GtkTextBuffer*", "GtkTextTag*", "const GtkTextIter*", "const GtkTextIter*"}, {"buffer", "tag", "start", "end"} }, 
    undo                = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['apply-tag']           = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextTag*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "tag", "start", "end"}} }, 
    ['begin-user-action']   = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    changed                 = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"buffer"}} }, 
    ['delete-range']        = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "start", "end"}} }, 
    ['end-user-action']     = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    ['insert-child-anchor'] = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextChildAnchor*"}, name ={"textbuffer", "location", "anchor"}} }, 
    ['insert-paintable']    = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "{Gdk.Paintable}"}, name ={"textbuffer", "location", "paintable"}} }, 
    ['insert-text']         = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "gchar*", "gint"}, name ={"textbuffer", "location", "text", "len"}} }, 
    ['mark-deleted']        = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextMark*"}, name ={"textbuffer", "mark"}} }, 
    ['mark-set']            = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextMark*"}, name ={"textbuffer", "location", "mark"}} }, 
    ['modified-changed']    = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    ['paste-done']          = {ret_type = "void", params = {type = {"GtkTextBuffer*", "{Gdk.Clipboard}"}, name ={"textbuffer", "clipboard"}} }, 
    redo                    = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"buffer"}} }, 
    ['remove-tag']          = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextTag*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "tag", "start", "end"}} }, 
    undo                    = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"buffer"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["can-redo"]        = {__type__="gboolean"         ,__default__ = "FALSE"  },
    ["can-undo"]        = {__type__="gboolean"         ,__default__ = "FALSE"  },
    ["cursor-position"] = {__type__="gint"             ,__default__ = "0"      },
    ["enable-undo"]     = {__type__="gboolean"         ,__default__ = "TRUE"  , __gencode__ = {"gtk_text_buffer_set_enable_undo((GtkTextBuffer*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-selection"]   = {__type__="gboolean"         ,__default__ = "FALSE"  },
    ["tag-table"]       = {__type__="GtkTextTagTable*"                        ,rwflags="rw" },
    text                = {__type__="gchar*"           ,__default__ = "\"\""  , __gencode__ = {"gtk_text_buffer_set_text((GtkTextBuffer*)({* id *}), (const char*)({* property.value *}), (int)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkTextChildAnchor
Gtk418.GtkTextChildAnchor = {
  class = "GtkTextChildAnchor", 
  constructor = { 
    -- 名称[- ==> _], 
    new                  = { gencode = "gtk_text_child_anchor_new()", 
            params = { type = {}, name = {} } },
    new_with_replacement = { gencode = "gtk_text_child_anchor_new_with_replacement((const char*)({* this.character.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTextMark
Gtk418.GtkTextMark = {
  class = "GtkTextMark", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_mark_new((const char*)({* this.name.value *}), (gboolean)({* this['left-gravity'].value *}))", 
            params = { type = {"const char*", "gboolean"}, 
                       name = {"name", "left-gravity"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["left-gravity"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    name             = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTextTag
Gtk418.GtkTextTag = {
  class = "GtkTextTag", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_tag_new((const char*)({* this.name.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"name"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accumulative-margin"]        = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["allow-breaks"]               = {__type__="gboolean"              ,__default__ = "TRUE"                      ,rwflags="rw" },
    ["allow-breaks-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    background                     = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="w" },
    ["background-full-height"]     = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["background-full-height-set"] = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["background-rgba"]            = {__type__="GdkRGBA*"                                                         ,rwflags="rw" },
    ["background-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    direction                      = {__type__="GtkTextDirection"      ,__default__ = "GTK_TEXT_DIR_NONE"         ,rwflags="rw" },
    editable                       = {__type__="gboolean"              ,__default__ = "TRUE"                      ,rwflags="rw" },
    ["editable-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    fallback                       = {__type__="gboolean"              ,__default__ = "TRUE"                      ,rwflags="rw" },
    ["fallback-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    family                         = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="rw" },
    ["family-set"]                 = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    font                           = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="rw" },
    ["font-desc"]                  = {__type__="PangoFontDescription*"                                            ,rwflags="rw" },
    ["font-features"]              = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="rw" },
    ["font-features-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    foreground                     = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="w" },
    ["foreground-rgba"]            = {__type__="GdkRGBA*"                                                         ,rwflags="rw" },
    ["foreground-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    indent                         = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["indent-set"]                 = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["insert-hyphens"]             = {__type__="gboolean"              ,__default__ = "TRUE"                      ,rwflags="rw" },
    ["insert-hyphens-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    invisible                      = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["invisible-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    justification                  = {__type__="GtkJustification"      ,__default__ = "GTK_JUSTIFY_LEFT"          ,rwflags="rw" },
    ["justification-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    language                       = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="rw" },
    ["language-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["left-margin"]                = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["left-margin-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["letter-spacing"]             = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["letter-spacing-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["line-height"]                = {__type__="gfloat"                ,__default__ = "0"                         ,rwflags="rw" },
    ["line-height-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    name                           = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="rw" },
    overline                       = {__type__="PangoOverline"         ,__default__ = "PANGO_OVERLINE_NONE"       ,rwflags="rw" },
    ["overline-rgba"]              = {__type__="GdkRGBA*"                                                         ,rwflags="rw" },
    ["overline-rgba-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["overline-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["paragraph-background"]       = {__type__="gchar*"                ,__default__ = "NULL"                      ,rwflags="w" },
    ["paragraph-background-rgba"]  = {__type__="GdkRGBA*"                                                         ,rwflags="rw" },
    ["paragraph-background-set"]   = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["pixels-above-lines"]         = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["pixels-above-lines-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["pixels-below-lines"]         = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["pixels-below-lines-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["pixels-inside-wrap"]         = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["pixels-inside-wrap-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["right-margin"]               = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["right-margin-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    rise                           = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["rise-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    scale                          = {__type__="gdouble"               ,__default__ = "1"                         ,rwflags="rw" },
    ["scale-set"]                  = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    sentence                       = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["sentence-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["show-spaces"]                = {__type__="PangoShowFlags"                                                   ,rwflags="rw" },
    ["show-spaces-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    size                           = {__type__="gint"                  ,__default__ = "0"                         ,rwflags="rw" },
    ["size-points"]                = {__type__="gdouble"               ,__default__ = "0"                         ,rwflags="rw" },
    ["size-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    stretch                        = {__type__="PangoStretch"          ,__default__ = "PANGO_STRETCH_NORMAL"      ,rwflags="rw" },
    ["stretch-set"]                = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    strikethrough                  = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["strikethrough-rgba"]         = {__type__="GdkRGBA*"                                                         ,rwflags="rw" },
    ["strikethrough-rgba-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["strikethrough-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    style                          = {__type__="PangoStyle"            ,__default__ = "PANGO_STYLE_NORMAL"        ,rwflags="rw" },
    ["style-set"]                  = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    tabs                           = {__type__="PangoTabArray*"                                                   ,rwflags="rw" },
    ["tabs-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["text-transform"]             = {__type__="PangoTextTransform"    ,__default__ = "PANGO_TEXT_TRANSFORM_NONE" ,rwflags="rw" },
    ["text-transform-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    underline                      = {__type__="PangoUnderline"        ,__default__ = "PANGO_UNDERLINE_NONE"      ,rwflags="rw" },
    ["underline-rgba"]             = {__type__="GdkRGBA*"                                                         ,rwflags="rw" },
    ["underline-rgba-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["underline-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    variant                        = {__type__="PangoVariant"          ,__default__ = "PANGO_VARIANT_NORMAL"      ,rwflags="rw" },
    ["variant-set"]                = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    weight                         = {__type__="gint"                  ,__default__ = "400"                       ,rwflags="rw" },
    ["weight-set"]                 = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    word                           = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["word-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
    ["wrap-mode"]                  = {__type__="GtkWrapMode"           ,__default__ = "GTK_WRAP_NONE"             ,rwflags="rw" },
    ["wrap-mode-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                     ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTextTagTable
Gtk418.GtkTextTagTable = {
  class = "GtkTextTagTable", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_tag_table_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['tag-added']   = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*"}, name ={"texttagtable", "tag"}} }, 
    ['tag-changed'] = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*", "gboolean"}, name ={"texttagtable", "tag", "size_changed"}} }, 
    ['tag-removed'] = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*"}, name ={"texttagtable", "tag"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkTooltip
Gtk418.GtkTooltip = {
  class = "GtkTooltip", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeListModel
Gtk418.GtkTreeListModel = {
  class = "GtkTreeListModel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tree_list_model_new((GListModel*)({* this.root.value *}), (gboolean)({* this.passthrough.value *}), (gboolean)({* this.autoexpand.value *}), (GtkTreeListModelCreateModelFunc)({* this.create_func.value *}), (gpointer)({* this.user_data.value *}), (GDestroyNotify)({* this.user_destroy.value *}))", 
            params = { type = {"gboolean", "gboolean"}, 
                       name = {"passthrough", "autoexpand"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    autoexpand    = {__type__="gboolean"    ,__default__ = "FALSE" , __gencode__ = {"gtk_tree_list_model_set_autoexpand((GtkTreeListModel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["item-type"] = {__type__="GType"                               },
    model         = {__type__="GListModel*"                         },
    ["n-items"]   = {__type__="guint"       ,__default__ = "0"      },
    passthrough   = {__type__="gboolean"    ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTreeListRow
Gtk418.GtkTreeListRow = {
  class = "GtkTreeListRow", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    children   = {__type__="GListModel*"                         },
    depth      = {__type__="guint"       ,__default__ = "0"      },
    expandable = {__type__="gboolean"    ,__default__ = "FALSE"  },
    expanded   = {__type__="gboolean"    ,__default__ = "FALSE" , __gencode__ = {"gtk_tree_list_row_set_expanded((GtkTreeListRow*)({* id *}), (gboolean)({* property.value *}))"} },
    item       = {__type__="GObject*"                            },
  },
  parent = nil, 
};

---------------------  GtkTreeModelFilter
Gtk418.GtkTreeModelFilter = {
  class = "GtkTreeModelFilter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    modify  = {"void"    , {"GtkTreeModelFilter*", "GtkTreeModel*", "GtkTreeIter*", "GValue*", "int"}, {"self", "child_model", "iter", "value", "column"} }, 
    visible = {"gboolean", {"GtkTreeModelFilter*", "GtkTreeModel*", "GtkTreeIter*"}, {"self", "child_model", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["child-model"]  = {__type__="GtkTreeModel*" ,rwflags="rw" },
    ["virtual-root"] = {__type__="GtkTreePath*"  ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk418.GtkTreeDragSource, Gtk418.GtkTreeModel}, 
};

---------------------  GtkTreeModelSort
Gtk418.GtkTreeModelSort = {
  class = "GtkTreeModelSort", 
  constructor = { 
    -- 名称[- ==> _], 
    new_with_model = { gencode = "gtk_tree_model_sort_new_with_model((GtkTreeModel*)({* this.child_model.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    model = {__type__="GtkTreeModel*" ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk418.GtkTreeDragSource, Gtk418.GtkTreeModel, Gtk418.GtkTreeSortable}, 
};

---------------------  GtkTreeSelection
Gtk418.GtkTreeSelection = {
  class = "GtkTreeSelection", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkTreeSelection*"}, name ={"treeselection"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    mode = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE" , __gencode__ = {"gtk_tree_selection_set_mode((GtkTreeSelection*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkTreeStore
Gtk418.GtkTreeStore = {
  class = "GtkTreeStore", 
  constructor = { 
    -- 名称[- ==> _], 
    new  = { gencode = "gtk_tree_store_new((int)({* this.n_columns.value *}), 0)", 
            params = { type = {}, name = {} } },
    newv = { gencode = "gtk_tree_store_newv((int)({* this.n_columns.value *}), (GType*)({* this.types.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable, Gtk418.GtkTreeDragDest, Gtk418.GtkTreeDragSource, Gtk418.GtkTreeModel, Gtk418.GtkTreeSortable}, 
};

---------------------  GtkTreeViewColumn
Gtk418.GtkTreeViewColumn = {
  class = "GtkTreeViewColumn", 
  constructor = { 
    -- 名称[- ==> _], 
    new                 = { gencode = "gtk_tree_view_column_new()", 
            params = { type = {}, name = {} } },
    new_with_area       = { gencode = "gtk_tree_view_column_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
    new_with_attributes = { gencode = "gtk_tree_view_column_new_with_attributes((const char*)({* this.title.value *}), (GtkCellRenderer*)({* this.cell.value *}), 0)", 
            params = { type = {"const char*"}, 
                       name = {"title"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    clicked = {ret_type = "void", params = {type = {"GtkTreeViewColumn*"}, name ={"treeviewcolumn"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    alignment          = {__type__="gfloat"                  ,__default__ = "0"                              , __gencode__ = {"gtk_tree_view_column_set_alignment((GtkTreeViewColumn*)({* id *}), (float)({* property.value *}))"} },
    ["cell-area"]      = {__type__="GtkCellArea*"                                                            ,rwflags="rw" },
    clickable          = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_clickable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    expand             = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_expand((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    ["fixed-width"]    = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_fixed_width((GtkTreeViewColumn*)({* id *}), (int)({* property.value *}))"} },
    ["max-width"]      = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_max_width((GtkTreeViewColumn*)({* id *}), (int)({* property.value *}))"} },
    ["min-width"]      = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_min_width((GtkTreeViewColumn*)({* id *}), (int)({* property.value *}))"} },
    reorderable        = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_reorderable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    resizable          = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_resizable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    sizing             = {__type__="GtkTreeViewColumnSizing" ,__default__ = "GTK_TREE_VIEW_COLUMN_GROW_ONLY" , __gencode__ = {"gtk_tree_view_column_set_sizing((GtkTreeViewColumn*)({* id *}), (GtkTreeViewColumnSizing)({* property.value *}))"} },
    ["sort-column-id"] = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_sort_column_id((GtkTreeViewColumn*)({* id *}), (int)({* property.value *}))"} },
    ["sort-indicator"] = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_sort_indicator((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    ["sort-order"]     = {__type__="GtkSortType"             ,__default__ = "GTK_SORT_ASCENDING"             , __gencode__ = {"gtk_tree_view_column_set_sort_order((GtkTreeViewColumn*)({* id *}), (GtkSortType)({* property.value *}))"} },
    spacing            = {__type__="gint"                    ,__default__ = "0"                              , __gencode__ = {"gtk_tree_view_column_set_spacing((GtkTreeViewColumn*)({* id *}), (int)({* property.value *}))"} },
    title              = {__type__="gchar*"                  ,__default__ = "\"\""                           , __gencode__ = {"gtk_tree_view_column_set_title((GtkTreeViewColumn*)({* id *}), (const char*)({* property.value *}))"} },
    visible            = {__type__="gboolean"                ,__default__ = "TRUE"                           , __gencode__ = {"gtk_tree_view_column_set_visible((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    widget             = {__type__="GtkWidget*"                                                              , __gencode__ = {"gtk_tree_view_column_set_widget((GtkTreeViewColumn*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    width              = {__type__="gint"                    ,__default__ = "0"                               },
    ["x-offset"]       = {__type__="gint"                    ,__default__ = "0"                               },
  },
  parent = nil, 
  implement = {Gtk418.GtkBuildable, Gtk418.GtkCellLayout}, 
};

---------------------  GtkUriLauncher
Gtk418.GtkUriLauncher = {
  class = "GtkUriLauncher", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_uri_launcher_new((const char*)({* this.uri.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"uri"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    uri = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_uri_launcher_set_uri((GtkUriLauncher*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkWidget
Gtk418.GtkWidget = {
  class = "GtkWidget", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    compute_expand         = {"void"              , {"GtkWidget*", "gboolean*", "gboolean*"}, {"widget", "hexpand_p", "vexpand_p"} }, 
    contains               = {"gboolean"          , {"GtkWidget*", "double", "double"}, {"widget", "x", "y"} }, 
    css_changed            = {"void"              , {"GtkWidget*", "GtkCssStyleChange*"}, {"widget", "change"} }, 
    direction_changed      = {"void"              , {"GtkWidget*", "GtkTextDirection"}, {"widget", "previous_direction"} }, 
    focus                  = {"gboolean"          , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    get_request_mode       = {"GtkSizeRequestMode", {"GtkWidget*"}, {"widget"} }, 
    grab_focus             = {"gboolean"          , {"GtkWidget*"}, {"widget"} }, 
    hide                   = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    keynav_failed          = {"gboolean"          , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    map                    = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    measure                = {"void"              , {"GtkWidget*", "GtkOrientation", "int", "int*", "int*", "int*", "int*"}, {"widget", "orientation", "for_size", "minimum", "natural", "minimum_baseline", "natural_baseline"} }, 
    mnemonic_activate      = {"gboolean"          , {"GtkWidget*", "gboolean"}, {"widget", "group_cycling"} }, 
    move_focus             = {"void"              , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    query_tooltip          = {"gboolean"          , {"GtkWidget*", "int", "int", "gboolean", "GtkTooltip*"}, {"widget", "x", "y", "keyboard_tooltip", "tooltip"} }, 
    realize                = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    root                   = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    set_focus_child        = {"void"              , {"GtkWidget*", "GtkWidget*"}, {"widget", "child"} }, 
    show                   = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    size_allocate          = {"void"              , {"GtkWidget*", "int", "int", "int"}, {"widget", "width", "height", "baseline"} }, 
    snapshot               = {"void"              , {"GtkWidget*", "GtkSnapshot*"}, {"widget", "snapshot"} }, 
    state_flags_changed    = {"void"              , {"GtkWidget*", "GtkStateFlags"}, {"widget", "previous_state_flags"} }, 
    system_setting_changed = {"void"              , {"GtkWidget*", "GtkSystemSetting"}, {"widget", "settings"} }, 
    unmap                  = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    unrealize              = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    unroot                 = {"void"              , {"GtkWidget*"}, {"widget"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    destroy                 = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['direction-changed']   = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkTextDirection"}, name ={"widget", "previous_direction"}} }, 
    hide                    = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['keynav-failed']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    map                     = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['mnemonic-activate']   = {ret_type = "gboolean", params = {type = {"GtkWidget*", "gboolean"}, name ={"widget", "group_cycling"}} }, 
    ['move-focus']          = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['query-tooltip']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "gint", "gint", "gboolean", "GtkTooltip*"}, name ={"widget", "x", "y", "keyboard_mode", "tooltip"}} }, 
    realize                 = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    show                    = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['state-flags-changed'] = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkStateFlags*"}, name ={"widget", "flags"}} }, 
    unmap                   = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    unrealize               = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["can-focus"]        = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_widget_set_can_focus((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["can-target"]       = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_widget_set_can_target((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["css-classes"]      = {__type__="GStrv"                                                   , __gencode__ = {"gtk_widget_set_css_classes((GtkWidget*)({* id *}), (const char**)({* property.value *}))"} },
    ["css-name"]         = {__type__="gchar*"            ,__default__ = "NULL"                 ,rwflags="rw" },
    cursor               = {__type__="GdkCursor*"                                              , __gencode__ = {"gtk_widget_set_cursor((GtkWidget*)({* id *}), (GdkCursor*)({* property.value *}))"} },
    ["focus-on-click"]   = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_widget_set_focus_on_click((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    focusable            = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_focusable((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    halign               = {__type__="GtkAlign"          ,__default__ = "GTK_ALIGN_FILL"       , __gencode__ = {"gtk_widget_set_halign((GtkWidget*)({* id *}), (GtkAlign)({* property.value *}))"} },
    ["has-default"]      = {__type__="gboolean"          ,__default__ = "FALSE"                 },
    ["has-focus"]        = {__type__="gboolean"          ,__default__ = "FALSE"                 },
    ["has-tooltip"]      = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_has_tooltip((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["height-request"]   = {__type__="gint"              ,__default__ = "-1"                   ,rwflags="rw" },
    hexpand              = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_hexpand((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hexpand-set"]      = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_hexpand_set((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["layout-manager"]   = {__type__="GtkLayoutManager*"                                       , __gencode__ = {"gtk_widget_set_layout_manager((GtkWidget*)({* id *}), (GtkLayoutManager*)({* property.value *}))"} },
    ["limit-events"]     = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_limit_events((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["margin-bottom"]    = {__type__="gint"              ,__default__ = "0"                    , __gencode__ = {"gtk_widget_set_margin_bottom((GtkWidget*)({* id *}), (int)({* property.value *}))"} },
    ["margin-end"]       = {__type__="gint"              ,__default__ = "0"                    , __gencode__ = {"gtk_widget_set_margin_end((GtkWidget*)({* id *}), (int)({* property.value *}))"} },
    ["margin-start"]     = {__type__="gint"              ,__default__ = "0"                    , __gencode__ = {"gtk_widget_set_margin_start((GtkWidget*)({* id *}), (int)({* property.value *}))"} },
    ["margin-top"]       = {__type__="gint"              ,__default__ = "0"                    , __gencode__ = {"gtk_widget_set_margin_top((GtkWidget*)({* id *}), (int)({* property.value *}))"} },
    name                 = {__type__="gchar*"            ,__default__ = "NULL"                 , __gencode__ = {"gtk_widget_set_name((GtkWidget*)({* id *}), (const char*)({* property.value *}))"} },
    opacity              = {__type__="gdouble"           ,__default__ = "1"                    , __gencode__ = {"gtk_widget_set_opacity((GtkWidget*)({* id *}), (double)({* property.value *}))"} },
    overflow             = {__type__="GtkOverflow"       ,__default__ = "GTK_OVERFLOW_VISIBLE" , __gencode__ = {"gtk_widget_set_overflow((GtkWidget*)({* id *}), (GtkOverflow)({* property.value *}))"} },
    parent               = {__type__="GtkWidget*"                                              , __gencode__ = {"gtk_widget_set_parent((GtkWidget*)({* id *}), (GtkWidget*)({* property.value *}))"},rwflags="r" },
    ["receives-default"] = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_receives_default((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    root                 = {__type__="GtkRoot*"                                                 },
    ["scale-factor"]     = {__type__="gint"              ,__default__ = "1"                     },
    sensitive            = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_widget_set_sensitive((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tooltip-markup"]   = {__type__="gchar*"            ,__default__ = "NULL"                 , __gencode__ = {"gtk_widget_set_tooltip_markup((GtkWidget*)({* id *}), (const char*)({* property.value *}))"} },
    ["tooltip-text"]     = {__type__="gchar*"            ,__default__ = "NULL"                 , __gencode__ = {"gtk_widget_set_tooltip_text((GtkWidget*)({* id *}), (const char*)({* property.value *}))"} },
    valign               = {__type__="GtkAlign"          ,__default__ = "GTK_ALIGN_FILL"       , __gencode__ = {"gtk_widget_set_valign((GtkWidget*)({* id *}), (GtkAlign)({* property.value *}))"} },
    vexpand              = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_vexpand((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["vexpand-set"]      = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_widget_set_vexpand_set((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    visible              = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_widget_set_visible((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["width-request"]    = {__type__="gint"              ,__default__ = "-1"                   ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkWidgetPaintable
Gtk418.GtkWidgetPaintable = {
  class = "GtkWidgetPaintable", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_widget_paintable_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    widget = {__type__="GtkWidget*" , __gencode__ = {"gtk_widget_paintable_set_widget((GtkWidgetPaintable*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkWindowGroup
Gtk418.GtkWindowGroup = {
  class = "GtkWindowGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_group_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkActionBar
Gtk418.GtkActionBar = {
  class = "GtkActionBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_action_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    revealed = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_action_bar_set_revealed((GtkActionBar*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkActivateAction
Gtk418.GtkActivateAction = {
  class = "GtkActivateAction", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkShortcutAction,
};

---------------------  GtkAlternativeTrigger
Gtk418.GtkAlternativeTrigger = {
  class = "GtkAlternativeTrigger", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_alternative_trigger_new((GtkShortcutTrigger*)({* this.first.value *}), (GtkShortcutTrigger*)({* this.second.value *}))", 
            params = { type = {"GtkShortcutTrigger*", "GtkShortcutTrigger*"}, 
                       name = {"first", "second"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    first  = {__type__="GtkShortcutTrigger*" ,rwflags="rw" },
    second = {__type__="GtkShortcutTrigger*" ,rwflags="rw" },
  },
  parent = Gtk418.GtkShortcutTrigger,
};

---------------------  GtkAppChooserButton
Gtk418.GtkAppChooserButton = {
  class = "GtkAppChooserButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_app_chooser_button_new((const char*)({* this['content-type']value *}))", 
            params = { type = {"const char*"}, 
                       name = {"content-type"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate                  = {ret_type = "void", params = {type = {"GtkAppChooserButton*"}, name ={"appchooserbutton"}} }, 
    changed                   = {ret_type = "void", params = {type = {"GtkAppChooserButton*"}, name ={"appchooserbutton"}} }, 
    ['custom-item-activated'] = {ret_type = "void", params = {type = {"GtkAppChooserButton*", "gchar*"}, name ={"appchooserbutton", "item_name"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    heading               = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_app_chooser_button_set_heading((GtkAppChooserButton*)({* id *}), (const char*)({* property.value *}))"} },
    modal                 = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_app_chooser_button_set_modal((GtkAppChooserButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-default-item"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_button_set_show_default_item((GtkAppChooserButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-dialog-item"]  = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_button_set_show_dialog_item((GtkAppChooserButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAppChooser, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkAppChooserWidget
Gtk418.GtkAppChooserWidget = {
  class = "GtkAppChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_app_chooser_widget_new((const char*)({* this['content-type']value *}))", 
            params = { type = {"const char*"}, 
                       name = {"content-type"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['application-activated'] = {ret_type = "void", params = {type = {"GtkAppChooserWidget*", "GAppInfo*"}, name ={"appchooserwidget", "application"}} }, 
    ['application-selected']  = {ret_type = "void", params = {type = {"GtkAppChooserWidget*", "GAppInfo*"}, name ={"appchooserwidget", "application"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["default-text"]     = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_app_chooser_widget_set_default_text((GtkAppChooserWidget*)({* id *}), (const char*)({* property.value *}))"} },
    ["show-all"]         = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_all((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-default"]     = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_default((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-fallback"]    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_fallback((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-other"]       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_other((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-recommended"] = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_app_chooser_widget_set_show_recommended((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAppChooser, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkAspectFrame
Gtk418.GtkAspectFrame = {
  class = "GtkAspectFrame", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_aspect_frame_new((float)({* this.xalign.value *}), (float)({* this.yalign.value *}), (float)({* this.ratio.value *}), (gboolean)({* this['obey-child'].value *}))", 
            params = { type = {"float", "float", "float", "gboolean"}, 
                       name = {"xalign", "yalign", "ratio", "obey-child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child          = {__type__="GtkWidget*"                       , __gencode__ = {"gtk_aspect_frame_set_child((GtkAspectFrame*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["obey-child"] = {__type__="gboolean"   ,__default__ = "TRUE" , __gencode__ = {"gtk_aspect_frame_set_obey_child((GtkAspectFrame*)({* id *}), (gboolean)({* property.value *}))"} },
    ratio          = {__type__="gfloat"     ,__default__ = "1"    , __gencode__ = {"gtk_aspect_frame_set_ratio((GtkAspectFrame*)({* id *}), (float)({* property.value *}))"} },
    xalign         = {__type__="gfloat"     ,__default__ = "0.5"  , __gencode__ = {"gtk_aspect_frame_set_xalign((GtkAspectFrame*)({* id *}), (float)({* property.value *}))"} },
    yalign         = {__type__="gfloat"     ,__default__ = "0.5"  , __gencode__ = {"gtk_aspect_frame_set_yalign((GtkAspectFrame*)({* id *}), (float)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkBinLayout
Gtk418.GtkBinLayout = {
  class = "GtkBinLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_bin_layout_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkLayoutManager,
};

---------------------  GtkBoolFilter
Gtk418.GtkBoolFilter = {
  class = "GtkBoolFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_bool_filter_new((GtkExpression*)({* this.expression.value *}))", 
            params = { type = {"GtkExpression*"}, 
                       name = {"expression"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expression = {__type__="GtkExpression*"                        , __gencode__ = {"gtk_bool_filter_set_expression((GtkBoolFilter*)({* id *}), (GtkExpression*)({* property.value *}))"} },
    invert     = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_bool_filter_set_invert((GtkBoolFilter*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkFilter,
};

---------------------  GtkBox
Gtk418.GtkBox = {
  class = "GtkBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_box_new((GtkOrientation)({* this.orientation.value *}), (int)({* this.spacing.value *}))", 
            params = { type = {"GtkOrientation", "int"}, 
                       name = {"orientation", "spacing"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-child"]    = {__type__="gint"                ,__default__ = "-1"                           , __gencode__ = {"gtk_box_set_baseline_child((GtkBox*)({* id *}), (int)({* property.value *}))"} },
    ["baseline-position"] = {__type__="GtkBaselinePosition" ,__default__ = "GTK_BASELINE_POSITION_CENTER" , __gencode__ = {"gtk_box_set_baseline_position((GtkBox*)({* id *}), (GtkBaselinePosition)({* property.value *}))"} },
    homogeneous           = {__type__="gboolean"            ,__default__ = "FALSE"                        , __gencode__ = {"gtk_box_set_homogeneous((GtkBox*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing               = {__type__="gint"                ,__default__ = "0"                            , __gencode__ = {"gtk_box_set_spacing((GtkBox*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkBoxLayout
Gtk418.GtkBoxLayout = {
  class = "GtkBoxLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_box_layout_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-child"]    = {__type__="gint"                ,__default__ = "-1"                           , __gencode__ = {"gtk_box_layout_set_baseline_child((GtkBoxLayout*)({* id *}), (int)({* property.value *}))"} },
    ["baseline-position"] = {__type__="GtkBaselinePosition" ,__default__ = "GTK_BASELINE_POSITION_CENTER" , __gencode__ = {"gtk_box_layout_set_baseline_position((GtkBoxLayout*)({* id *}), (GtkBaselinePosition)({* property.value *}))"} },
    homogeneous           = {__type__="gboolean"            ,__default__ = "FALSE"                        , __gencode__ = {"gtk_box_layout_set_homogeneous((GtkBoxLayout*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing               = {__type__="gint"                ,__default__ = "0"                            , __gencode__ = {"gtk_box_layout_set_spacing((GtkBoxLayout*)({* id *}), (guint)({* property.value *}))"} },
  },
  parent = Gtk418.GtkLayoutManager,
  implement = {Gtk418.GtkOrientable}, 
};

---------------------  GtkBuilderListItemFactory
Gtk418.GtkBuilderListItemFactory = {
  class = "GtkBuilderListItemFactory", 
  constructor = { 
    -- 名称[- ==> _], 
    new_from_bytes    = { gencode = "gtk_builder_list_item_factory_new_from_bytes((GtkBuilderScope*)({* this.scope.value *}), (GBytes*)({* this.bytes.value *}))", 
            params = { type = {"GtkBuilderScope*", "GBytes*"}, 
                       name = {"scope", "bytes"} } },
    new_from_resource = { gencode = "gtk_builder_list_item_factory_new_from_resource((GtkBuilderScope*)({* this.scope.value *}), (const char*)({* this.resource_path.value *}))", 
            params = { type = {"GtkBuilderScope*"}, 
                       name = {"scope"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    bytes    = {__type__="GBytes*"                                ,rwflags="rw" },
    resource = {__type__="gchar*"           ,__default__ = "NULL" ,rwflags="rw" },
    scope    = {__type__="GtkBuilderScope*"                       ,rwflags="rw" },
  },
  parent = Gtk418.GtkListItemFactory,
};

---------------------  GtkButton
Gtk418.GtkButton = {
  class = "GtkButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_button_new()", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_button_new_from_icon_name((const char*)({* this['icon-name']value *}))", 
            params = { type = {"const char*"}, 
                       name = {"icon-name"} } },
    new_with_label     = { gencode = "gtk_button_new_with_label((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
    new_with_mnemonic  = { gencode = "gtk_button_new_with_mnemonic((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkButton*"}, {"button"} }, 
    clicked  = {"void", {"GtkButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    clicked  = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["can-shrink"]    = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_button_set_can_shrink((GtkButton*)({* id *}), (gboolean)({* property.value *}))"} },
    child             = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_button_set_child((GtkButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["has-frame"]     = {__type__="gboolean"   ,__default__ = "TRUE"  , __gencode__ = {"gtk_button_set_has_frame((GtkButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["icon-name"]     = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_button_set_icon_name((GtkButton*)({* id *}), (const char*)({* property.value *}))"} },
    label             = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_button_set_label((GtkButton*)({* id *}), (const char*)({* property.value *}))"} },
    ["use-underline"] = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_button_set_use_underline((GtkButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkCClosureExpression
Gtk418.GtkCClosureExpression = {
  class = "GtkCClosureExpression", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cclosure_expression_new((GType)({* this.value_type.value *}), (GClosureMarshal)({* this.marshal.value *}), (guint)({* this.n_params.value *}), (GtkExpression**)({* this.params.value *}), (GCallback)({* this.callback_func.value *}), (gpointer)({* this.user_data.value *}), (GClosureNotify)({* this.user_destroy.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkExpression,
};

---------------------  GtkCalendar
Gtk418.GtkCalendar = {
  class = "GtkCalendar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_calendar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['day-selected'] = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['next-month']   = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['next-year']    = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['prev-month']   = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['prev-year']    = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    day                   = {__type__="gint"     ,__default__ = "1"     , __gencode__ = {"gtk_calendar_set_day((GtkCalendar*)({* id *}), (int)({* property.value *}))"} },
    month                 = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_calendar_set_month((GtkCalendar*)({* id *}), (int)({* property.value *}))"} },
    ["show-day-names"]    = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_calendar_set_show_day_names((GtkCalendar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-heading"]      = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_calendar_set_show_heading((GtkCalendar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-week-numbers"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_calendar_set_show_week_numbers((GtkCalendar*)({* id *}), (gboolean)({* property.value *}))"} },
    year                  = {__type__="gint"     ,__default__ = "1"     , __gencode__ = {"gtk_calendar_set_year((GtkCalendar*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkCallbackAction
Gtk418.GtkCallbackAction = {
  class = "GtkCallbackAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_callback_action_new((GtkShortcutFunc)({* this.callback.value *}), (gpointer)({* this.data.value *}), (GDestroyNotify)({* this.destroy.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkShortcutAction,
};

---------------------  GtkCellAreaBox
Gtk418.GtkCellAreaBox = {
  class = "GtkCellAreaBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_area_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    spacing = {__type__="gint" ,__default__ = "0" , __gencode__ = {"gtk_cell_area_box_set_spacing((GtkCellAreaBox*)({* id *}), (int)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    align          = {__type__="gboolean"    ,__default__ = "FALSE" },
    expand         = {__type__="gboolean"    ,__default__ = "FALSE" },
    ["fixed-size"] = {__type__="gboolean"    ,__default__ = "TRUE" },
    ["pack-type"]  = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
  },
  parent = Gtk418.GtkCellArea,
  implement = {Gtk418.GtkBuildable, Gtk418.GtkCellLayout, Gtk418.GtkOrientable}, 
};

---------------------  GtkCellRendererPixbuf
Gtk418.GtkCellRendererPixbuf = {
  class = "GtkCellRendererPixbuf", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_pixbuf_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    gicon                      = {__type__="GIcon*"                                             ,rwflags="rw" },
    ["icon-name"]              = {__type__="gchar*"      ,__default__ = "NULL"                  ,rwflags="rw" },
    ["icon-size"]              = {__type__="GtkIconSize" ,__default__ = "GTK_ICON_SIZE_INHERIT" ,rwflags="rw" },
    pixbuf                     = {__type__="GdkPixbuf*"                                         ,rwflags="w" },
    ["pixbuf-expander-closed"] = {__type__="GdkPixbuf*"                                         ,rwflags="rw" },
    ["pixbuf-expander-open"]   = {__type__="GdkPixbuf*"                                         ,rwflags="rw" },
    texture                    = {__type__="GdkTexture*"                                        ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRenderer,
};

---------------------  GtkCellRendererProgress
Gtk418.GtkCellRendererProgress = {
  class = "GtkCellRendererProgress", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_progress_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    inverted        = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    pulse           = {__type__="gint"     ,__default__ = "-1"    ,rwflags="rw" },
    text            = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
    ["text-xalign"] = {__type__="gfloat"   ,__default__ = "0.5"   ,rwflags="rw" },
    ["text-yalign"] = {__type__="gfloat"   ,__default__ = "0.5"   ,rwflags="rw" },
    value           = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRenderer,
  implement = {Gtk418.GtkOrientable}, 
};

---------------------  GtkCellRendererSpinner
Gtk418.GtkCellRendererSpinner = {
  class = "GtkCellRendererSpinner", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_spinner_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean"    ,__default__ = "FALSE"                 ,rwflags="rw" },
    pulse  = {__type__="guint"       ,__default__ = "0"                     ,rwflags="rw" },
    size   = {__type__="GtkIconSize" ,__default__ = "GTK_ICON_SIZE_INHERIT" ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRenderer,
};

---------------------  GtkCellRendererText
Gtk418.GtkCellRendererText = {
  class = "GtkCellRendererText", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_text_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    edited = {"void", {"GtkCellRendererText*", "const char*", "const char*"}, {"cell_renderer_text", "path", "new_text"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    edited = {ret_type = "void", params = {type = {"GtkCellRendererText*", "const char*", "const char*"}, name ={"cell_renderer_text", "path", "new_text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["align-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    alignment                 = {__type__="PangoAlignment"        ,__default__ = "PANGO_ALIGN_LEFT"     ,rwflags="rw" },
    attributes                = {__type__="PangoAttrList*"                                              ,rwflags="rw" },
    background                = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["background-rgba"]       = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["background-set"]        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    editable                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["editable-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ellipsize                 = {__type__="PangoEllipsizeMode"    ,__default__ = "PANGO_ELLIPSIZE_NONE" ,rwflags="rw" },
    ["ellipsize-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    family                    = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["family-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    font                      = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["font-desc"]             = {__type__="PangoFontDescription*"                                       ,rwflags="rw" },
    foreground                = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["foreground-rgba"]       = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["foreground-set"]        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    language                  = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["language-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    markup                    = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["max-width-chars"]       = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
    ["placeholder-text"]      = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    rise                      = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["rise-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    scale                     = {__type__="gdouble"               ,__default__ = "1"                    ,rwflags="rw" },
    ["scale-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["single-paragraph-mode"] = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    size                      = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["size-points"]           = {__type__="gdouble"               ,__default__ = "0"                    ,rwflags="rw" },
    ["size-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    stretch                   = {__type__="PangoStretch"          ,__default__ = "PANGO_STRETCH_NORMAL" ,rwflags="rw" },
    ["stretch-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["strikethrough-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    style                     = {__type__="PangoStyle"            ,__default__ = "PANGO_STYLE_NORMAL"   ,rwflags="rw" },
    ["style-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    text                      = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    underline                 = {__type__="PangoUnderline"        ,__default__ = "PANGO_UNDERLINE_NONE" ,rwflags="rw" },
    ["underline-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    variant                   = {__type__="PangoVariant"          ,__default__ = "PANGO_VARIANT_NORMAL" ,rwflags="rw" },
    ["variant-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    weight                    = {__type__="gint"                  ,__default__ = "400"                  ,rwflags="rw" },
    ["weight-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["width-chars"]           = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
    ["wrap-mode"]             = {__type__="PangoWrapMode"         ,__default__ = "PANGO_WRAP_CHAR"      ,rwflags="rw" },
    ["wrap-width"]            = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRenderer,
};

---------------------  GtkCellRendererToggle
Gtk418.GtkCellRendererToggle = {
  class = "GtkCellRendererToggle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_toggle_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkCellRendererToggle*", "gchar*"}, name ={"cellrenderertoggle", "path"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activatable  = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_cell_renderer_toggle_set_activatable((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
    active       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_renderer_toggle_set_active((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
    inconsistent = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    radio        = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkCellRenderer,
};

---------------------  GtkCellView
Gtk418.GtkCellView = {
  class = "GtkCellView", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_cell_view_new()", 
            params = { type = {}, name = {} } },
    new_with_context = { gencode = "gtk_cell_view_new_with_context((GtkCellArea*)({* this.area.value *}), (GtkCellAreaContext*)({* this.context.value *}))", 
            params = { type = {}, name = {} } },
    new_with_markup  = { gencode = "gtk_cell_view_new_with_markup((const char*)({* this.markup.value *}))", 
            params = { type = {}, name = {} } },
    new_with_text    = { gencode = "gtk_cell_view_new_with_text((const char*)({* this.text.value *}))", 
            params = { type = {}, name = {} } },
    new_with_texture = { gencode = "gtk_cell_view_new_with_texture((GdkTexture*)({* this.texture.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cell-area"]         = {__type__="GtkCellArea*"                               ,rwflags="rw" },
    ["cell-area-context"] = {__type__="GtkCellAreaContext*"                        ,rwflags="rw" },
    ["draw-sensitive"]    = {__type__="gboolean"            ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_view_set_draw_sensitive((GtkCellView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["fit-model"]         = {__type__="gboolean"            ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_view_set_fit_model((GtkCellView*)({* id *}), (gboolean)({* property.value *}))"} },
    model                 = {__type__="GtkTreeModel*"                              , __gencode__ = {"gtk_cell_view_set_model((GtkCellView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkCellLayout, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkCenterBox
Gtk418.GtkCenterBox = {
  class = "GtkCenterBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_center_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-position"]  = {__type__="GtkBaselinePosition" ,__default__ = "GTK_BASELINE_POSITION_CENTER" , __gencode__ = {"gtk_center_box_set_baseline_position((GtkCenterBox*)({* id *}), (GtkBaselinePosition)({* property.value *}))"} },
    ["center-widget"]      = {__type__="GtkWidget*"                                                        , __gencode__ = {"gtk_center_box_set_center_widget((GtkCenterBox*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["end-widget"]         = {__type__="GtkWidget*"                                                        , __gencode__ = {"gtk_center_box_set_end_widget((GtkCenterBox*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["shrink-center-last"] = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_center_box_set_shrink_center_last((GtkCenterBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["start-widget"]       = {__type__="GtkWidget*"                                                        , __gencode__ = {"gtk_center_box_set_start_widget((GtkCenterBox*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkCenterLayout
Gtk418.GtkCenterLayout = {
  class = "GtkCenterLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_center_layout_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["shrink-center-last"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_center_layout_set_shrink_center_last((GtkCenterLayout*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkLayoutManager,
};

---------------------  GtkCheckButton
Gtk418.GtkCheckButton = {
  class = "GtkCheckButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_check_button_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_check_button_new_with_label((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_check_button_new_with_mnemonic((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkCheckButton*"}, {"check_button"} }, 
    toggled  = {"void", {"GtkCheckButton*"}, {"check_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkCheckButton*"}, name ={"check_button"}} }, 
    toggled  = {ret_type = "void", params = {type = {"GtkCheckButton*"}, name ={"check_button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active            = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_check_button_set_active((GtkCheckButton*)({* id *}), (gboolean)({* property.value *}))"} },
    child             = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_check_button_set_child((GtkCheckButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    group             = {__type__="GtkCheckButton*"                        , __gencode__ = {"gtk_check_button_set_group((GtkCheckButton*)({* id *}), (GtkCheckButton*)({* property.value *}))"} },
    inconsistent      = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_check_button_set_inconsistent((GtkCheckButton*)({* id *}), (gboolean)({* property.value *}))"} },
    label             = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_check_button_set_label((GtkCheckButton*)({* id *}), (const char*)({* property.value *}))"} },
    ["use-underline"] = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_check_button_set_use_underline((GtkCheckButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkClosureExpression
Gtk418.GtkClosureExpression = {
  class = "GtkClosureExpression", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_closure_expression_new((GType)({* this.value_type.value *}), (GClosure*)({* this.closure.value *}), (guint)({* this.n_params.value *}), (GtkExpression**)({* this.params.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkExpression,
};

---------------------  GtkColorButton
Gtk418.GtkColorButton = {
  class = "GtkColorButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_color_button_new()", 
            params = { type = {}, name = {} } },
    new_with_rgba = { gencode = "gtk_color_button_new_with_rgba((const GdkRGBA*)({* this.rgba.value *}))", 
            params = { type = {"const GdkRGBA*"}, 
                       name = {"rgba"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate      = {ret_type = "void", params = {type = {"GtkColorButton*"}, name ={"colorbutton"}} }, 
    ['color-set'] = {ret_type = "void", params = {type = {"GtkColorButton*"}, name ={"colorbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    modal           = {__type__="gboolean" ,__default__ = "TRUE"             , __gencode__ = {"gtk_color_button_set_modal((GtkColorButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-editor"] = {__type__="gboolean" ,__default__ = "FALSE"            ,rwflags="rw" },
    title           = {__type__="gchar*"   ,__default__ = "\"Pick a Color\"" , __gencode__ = {"gtk_color_button_set_title((GtkColorButton*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkColorChooser, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkColorChooserWidget
Gtk418.GtkColorChooserWidget = {
  class = "GtkColorChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_chooser_widget_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-editor"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkColorChooser, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkColorDialogButton
Gtk418.GtkColorDialogButton = {
  class = "GtkColorDialogButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_dialog_button_new((GtkColorDialog*)({* this.dialog.value *}))", 
            params = { type = {"GtkColorDialog*"}, 
                       name = {"dialog"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkColorDialogButton*"}, name ={"colordialogbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    dialog = {__type__="GtkColorDialog*" , __gencode__ = {"gtk_color_dialog_button_set_dialog((GtkColorDialogButton*)({* id *}), (GtkColorDialog*)({* property.value *}))"} },
    rgba   = {__type__="GdkRGBA*"        , __gencode__ = {"gtk_color_dialog_button_set_rgba((GtkColorDialogButton*)({* id *}), (const GdkRGBA*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkColumnView
Gtk418.GtkColumnView = {
  class = "GtkColumnView", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_column_view_new((GtkSelectionModel*)({* this.model.value *}))", 
            params = { type = {"GtkSelectionModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkColumnView*", "guint"}, name ={"columnview", "position"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    columns                    = {__type__="GListModel*"                                            },
    ["enable-rubberband"]      = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_column_view_set_enable_rubberband((GtkColumnView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["header-factory"]         = {__type__="GtkListItemFactory*"                                   , __gencode__ = {"gtk_column_view_set_header_factory((GtkColumnView*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    model                      = {__type__="GtkSelectionModel*"                                    , __gencode__ = {"gtk_column_view_set_model((GtkColumnView*)({* id *}), (GtkSelectionModel*)({* property.value *}))"} },
    reorderable                = {__type__="gboolean"            ,__default__ = "TRUE"             , __gencode__ = {"gtk_column_view_set_reorderable((GtkColumnView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["row-factory"]            = {__type__="GtkListItemFactory*"                                   , __gencode__ = {"gtk_column_view_set_row_factory((GtkColumnView*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    ["show-column-separators"] = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_column_view_set_show_column_separators((GtkColumnView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-row-separators"]    = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_column_view_set_show_row_separators((GtkColumnView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["single-click-activate"]  = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_column_view_set_single_click_activate((GtkColumnView*)({* id *}), (gboolean)({* property.value *}))"} },
    sorter                     = {__type__="GtkSorter*"                                             },
    ["tab-behavior"]           = {__type__="GtkListTabBehavior"  ,__default__ = "GTK_LIST_TAB_ALL" , __gencode__ = {"gtk_column_view_set_tab_behavior((GtkColumnView*)({* id *}), (GtkListTabBehavior)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkScrollable}, 
};

---------------------  GtkColumnViewCell
Gtk418.GtkColumnViewCell = {
  class = "GtkColumnViewCell", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child     = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_column_view_cell_set_child((GtkColumnViewCell*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    focusable = {__type__="gboolean"   ,__default__ = "FALSE"      , __gencode__ = {"gtk_column_view_cell_set_focusable((GtkColumnViewCell*)({* id *}), (gboolean)({* property.value *}))"} },
    item      = {__type__="GObject*"                                },
    position  = {__type__="guint"      ,__default__ = "4294967295"  },
    selected  = {__type__="gboolean"   ,__default__ = "FALSE"       },
  },
  parent = Gtk418.GtkListItem,
};

---------------------  GtkColumnViewSorter
Gtk418.GtkColumnViewSorter = {
  class = "GtkColumnViewSorter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["primary-sort-column"] = {__type__="GtkColumnViewColumn*"                                      },
    ["primary-sort-order"]  = {__type__="GtkSortType"          ,__default__ = "GTK_SORT_ASCENDING"  },
  },
  parent = Gtk418.GtkSorter,
};

---------------------  GtkComboBox
Gtk418.GtkComboBox = {
  class = "GtkComboBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new                      = { gencode = "gtk_combo_box_new()", 
            params = { type = {}, name = {} } },
    new_with_entry           = { gencode = "gtk_combo_box_new_with_entry()", 
            params = { type = {}, name = {} } },
    new_with_model           = { gencode = "gtk_combo_box_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
    new_with_model_and_entry = { gencode = "gtk_combo_box_new_with_model_and_entry((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate          = {"void" , {"GtkComboBox*"}, {"combo_box"} }, 
    changed           = {"void" , {"GtkComboBox*"}, {"combo_box"} }, 
    format_entry_text = {"char*", {"GtkComboBox*", "const char*"}, {"combo_box", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate              = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combo_box"}} }, 
    changed               = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combo_box"}} }, 
    ['format-entry-text'] = {ret_type = "gchar*"  , params = {type = {"GtkComboBox*", "gchar*"}, name ={"combobox", "path"}} }, 
    ['move-active']       = {ret_type = "void"    , params = {type = {"GtkComboBox*", "GtkScrollType"}, name ={"combobox", "scroll_type"}} }, 
    popdown               = {ret_type = "gboolean", params = {type = {"GtkComboBox*"}, name ={"combobox"}} }, 
    popup                 = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combobox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active                 = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_active((GtkComboBox*)({* id *}), (int)({* property.value *}))"} },
    ["active-id"]          = {__type__="gchar*"             ,__default__ = "NULL"                 , __gencode__ = {"gtk_combo_box_set_active_id((GtkComboBox*)({* id *}), (const char*)({* property.value *}))"} },
    ["button-sensitivity"] = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO" , __gencode__ = {"gtk_combo_box_set_button_sensitivity((GtkComboBox*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
    child                  = {__type__="GtkWidget*"                                               , __gencode__ = {"gtk_combo_box_set_child((GtkComboBox*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["entry-text-column"]  = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_entry_text_column((GtkComboBox*)({* id *}), (int)({* property.value *}))"} },
    ["has-entry"]          = {__type__="gboolean"           ,__default__ = "FALSE"                ,rwflags="rw" },
    ["has-frame"]          = {__type__="gboolean"           ,__default__ = "TRUE"                 ,rwflags="rw" },
    ["id-column"]          = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_id_column((GtkComboBox*)({* id *}), (int)({* property.value *}))"} },
    model                  = {__type__="GtkTreeModel*"                                            , __gencode__ = {"gtk_combo_box_set_model((GtkComboBox*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    ["popup-fixed-width"]  = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_combo_box_set_popup_fixed_width((GtkComboBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["popup-shown"]        = {__type__="gboolean"           ,__default__ = "FALSE"                 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkCellEditable, Gtk418.GtkCellLayout, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkConstantExpression
Gtk418.GtkConstantExpression = {
  class = "GtkConstantExpression", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_constant_expression_new((GType)({* this.value_type.value *}), 0)", 
            params = { type = {}, name = {} } },
    new_for_value = { gencode = "gtk_constant_expression_new_for_value((const GValue*)({* this.value.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkExpression,
};

---------------------  GtkConstraintLayout
Gtk418.GtkConstraintLayout = {
  class = "GtkConstraintLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_constraint_layout_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkLayoutManager,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkConstraintLayoutChild
Gtk418.GtkConstraintLayoutChild = {
  class = "GtkConstraintLayoutChild", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkLayoutChild,
};

---------------------  GtkCustomFilter
Gtk418.GtkCustomFilter = {
  class = "GtkCustomFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_custom_filter_new((GtkCustomFilterFunc)({* this.match_func.value *}), (gpointer)({* this.user_data.value *}), (GDestroyNotify)({* this.user_destroy.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkFilter,
};

---------------------  GtkCustomLayout
Gtk418.GtkCustomLayout = {
  class = "GtkCustomLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_custom_layout_new((GtkCustomRequestModeFunc)({* this.request_mode.value *}), (GtkCustomMeasureFunc)({* this.measure.value *}), (GtkCustomAllocateFunc)({* this.allocate.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkLayoutManager,
};

---------------------  GtkCustomSorter
Gtk418.GtkCustomSorter = {
  class = "GtkCustomSorter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_custom_sorter_new((GCompareDataFunc)({* this.sort_func.value *}), (gpointer)({* this.user_data.value *}), (GDestroyNotify)({* this.user_destroy.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkSorter,
};

---------------------  GtkDragIcon
Gtk418.GtkDragIcon = {
  class = "GtkDragIcon", 
  constructor = { 
    -- 名称[- ==> _], 
    get_for_drag = { gencode = "gtk_drag_icon_get_for_drag((GdkDrag*)({* this.drag.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child = {__type__="GtkWidget*" , __gencode__ = {"gtk_drag_icon_set_child((GtkDragIcon*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot}, 
};

---------------------  GtkDrawingArea
Gtk418.GtkDrawingArea = {
  class = "GtkDrawingArea", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drawing_area_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    resize = {"void", {"GtkDrawingArea*", "int", "int"}, {"area", "width", "height"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    resize = {ret_type = "void", params = {type = {"GtkDrawingArea*", "int", "int"}, name ={"area", "width", "height"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["content-height"] = {__type__="gint" ,__default__ = "0" , __gencode__ = {"gtk_drawing_area_set_content_height((GtkDrawingArea*)({* id *}), (int)({* property.value *}))"} },
    ["content-width"]  = {__type__="gint" ,__default__ = "0" , __gencode__ = {"gtk_drawing_area_set_content_width((GtkDrawingArea*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkDropControllerMotion
Gtk418.GtkDropControllerMotion = {
  class = "GtkDropControllerMotion", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drop_controller_motion_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    enter  = {ret_type = "void", params = {type = {"GtkDropControllerMotion*", "gdouble", "gdouble"}, name ={"dropcontrollermotion", "x", "y"}} }, 
    leave  = {ret_type = "void", params = {type = {"GtkDropControllerMotion*"}, name ={"dropcontrollermotion"}} }, 
    motion = {ret_type = "void", params = {type = {"GtkDropControllerMotion*", "gdouble", "gdouble"}, name ={"dropcontrollermotion", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["contains-pointer"] = {__type__="gboolean" ,__default__ = "FALSE"  },
    drop                 = {__type__="GdkDrop*"                         },
    ["is-pointer"]       = {__type__="gboolean" ,__default__ = "FALSE"  },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkDropDown
Gtk418.GtkDropDown = {
  class = "GtkDropDown", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_drop_down_new((GListModel*)({* this.model.value *}), (GtkExpression*)({* this.expression.value *}))", 
            params = { type = {"GListModel*", "GtkExpression*"}, 
                       name = {"model", "expression"} } },
    new_from_strings = { gencode = "gtk_drop_down_new_from_strings((const char* const*)({* this.strings.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkDropDown*"}, name ={"dropdown"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["enable-search"]     = {__type__="gboolean"                 ,__default__ = "FALSE"                               , __gencode__ = {"gtk_drop_down_set_enable_search((GtkDropDown*)({* id *}), (gboolean)({* property.value *}))"} },
    expression            = {__type__="GtkExpression*"                                                                , __gencode__ = {"gtk_drop_down_set_expression((GtkDropDown*)({* id *}), (GtkExpression*)({* property.value *}))"} },
    factory               = {__type__="GtkListItemFactory*"                                                           , __gencode__ = {"gtk_drop_down_set_factory((GtkDropDown*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    ["header-factory"]    = {__type__="GtkListItemFactory*"                                                           , __gencode__ = {"gtk_drop_down_set_header_factory((GtkDropDown*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    ["list-factory"]      = {__type__="GtkListItemFactory*"                                                           , __gencode__ = {"gtk_drop_down_set_list_factory((GtkDropDown*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    model                 = {__type__="GListModel*"                                                                   , __gencode__ = {"gtk_drop_down_set_model((GtkDropDown*)({* id *}), (GListModel*)({* property.value *}))"} },
    ["search-match-mode"] = {__type__="GtkStringFilterMatchMode" ,__default__ = "GTK_STRING_FILTER_MATCH_MODE_PREFIX" , __gencode__ = {"gtk_drop_down_set_search_match_mode((GtkDropDown*)({* id *}), (GtkStringFilterMatchMode)({* property.value *}))"} },
    selected              = {__type__="guint"                    ,__default__ = "4294967295"                          , __gencode__ = {"gtk_drop_down_set_selected((GtkDropDown*)({* id *}), (guint)({* property.value *}))"} },
    ["selected-item"]     = {__type__="GObject*"                                                                       },
    ["show-arrow"]        = {__type__="gboolean"                 ,__default__ = "TRUE"                                , __gencode__ = {"gtk_drop_down_set_show_arrow((GtkDropDown*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkDropTarget
Gtk418.GtkDropTarget = {
  class = "GtkDropTarget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drop_target_new((GType)({* this.type.value *}), (GdkDragAction)({* this.actions.value *}))", 
            params = { type = {"GdkDragAction"}, 
                       name = {"actions"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    accept = {ret_type = "gboolean"        , params = {type = {"GtkDropTarget*", "{Gdk.Drop}"}, name ={"droptarget", "drop"}} }, 
    drop   = {ret_type = "gboolean"        , params = {type = {"GtkDropTarget*", "{GObject.Value}", "gdouble", "gdouble"}, name ={"droptarget", "value", "x", "y"}} }, 
    enter  = {ret_type = "{Gdk.DragAction}", params = {type = {"GtkDropTarget*", "gdouble", "gdouble"}, name ={"droptarget", "x", "y"}} }, 
    leave  = {ret_type = "void"            , params = {type = {"GtkDropTarget*"}, name ={"droptarget"}} }, 
    motion = {ret_type = "{Gdk.DragAction}", params = {type = {"GtkDropTarget*", "gdouble", "gdouble"}, name ={"droptarget", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    actions          = {__type__="GdkDragAction"                             , __gencode__ = {"gtk_drop_target_set_actions((GtkDropTarget*)({* id *}), (GdkDragAction)({* property.value *}))"} },
    ["current-drop"] = {__type__="GdkDrop*"                                   },
    drop             = {__type__="GdkDrop*"                                   },
    formats          = {__type__="GdkContentFormats*"                        ,rwflags="rw" },
    preload          = {__type__="gboolean"           ,__default__ = "FALSE" , __gencode__ = {"gtk_drop_target_set_preload((GtkDropTarget*)({* id *}), (gboolean)({* property.value *}))"} },
    value            = {__type__="GValue*"                                    },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkDropTargetAsync
Gtk418.GtkDropTargetAsync = {
  class = "GtkDropTargetAsync", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drop_target_async_new((GdkContentFormats*)({* this.formats.value *}), (GdkDragAction)({* this.actions.value *}))", 
            params = { type = {"GdkContentFormats*", "GdkDragAction"}, 
                       name = {"formats", "actions"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    accept          = {ret_type = "gboolean"        , params = {type = {"GtkDropTargetAsync*", "{Gdk.Drop}"}, name ={"droptargetasync", "drop"}} }, 
    ['drag-enter']  = {ret_type = "{Gdk.DragAction}", params = {type = {"GtkDropTargetAsync*", "{Gdk.Drop}", "gdouble", "gdouble"}, name ={"droptargetasync", "drop", "x", "y"}} }, 
    ['drag-leave']  = {ret_type = "void"            , params = {type = {"GtkDropTargetAsync*", "{Gdk.Drop}"}, name ={"droptargetasync", "drop"}} }, 
    ['drag-motion'] = {ret_type = "{Gdk.DragAction}", params = {type = {"GtkDropTargetAsync*", "{Gdk.Drop}", "gdouble", "gdouble"}, name ={"droptargetasync", "drop", "x", "y"}} }, 
    drop            = {ret_type = "gboolean"        , params = {type = {"GtkDropTargetAsync*", "{Gdk.Drop}", "gdouble", "gdouble"}, name ={"droptargetasync", "drop", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    actions = {__type__="GdkDragAction"      , __gencode__ = {"gtk_drop_target_async_set_actions((GtkDropTargetAsync*)({* id *}), (GdkDragAction)({* property.value *}))"} },
    formats = {__type__="GdkContentFormats*" , __gencode__ = {"gtk_drop_target_async_set_formats((GtkDropTargetAsync*)({* id *}), (GdkContentFormats*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkEditableLabel
Gtk418.GtkEditableLabel = {
  class = "GtkEditableLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_editable_label_new((const char*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    editing = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkEditable}, 
};

---------------------  GtkEntry
Gtk418.GtkEntry = {
  class = "GtkEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_entry_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer = { gencode = "gtk_entry_new_with_buffer((GtkEntryBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkEntryBuffer*"}, 
                       name = {"buffer"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkEntry*"}, {"entry"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate         = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['icon-press']   = {ret_type = "void", params = {type = {"GtkEntry*", "GtkEntryIconPosition"}, name ={"entry", "icon_pos"}} }, 
    ['icon-release'] = {ret_type = "void", params = {type = {"GtkEntry*", "GtkEntryIconPosition"}, name ={"entry", "icon_pos"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activates-default"]             = {__type__="gboolean"            ,__default__ = "FALSE"                       , __gencode__ = {"gtk_entry_set_activates_default((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    attributes                        = {__type__="PangoAttrList*"                                                   , __gencode__ = {"gtk_entry_set_attributes((GtkEntry*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    buffer                            = {__type__="GtkEntryBuffer*"                                                  , __gencode__ = {"gtk_entry_set_buffer((GtkEntry*)({* id *}), (GtkEntryBuffer*)({* property.value *}))"},__construct__= 1 },
    completion                        = {__type__="GtkEntryCompletion*"                                              , __gencode__ = {"gtk_entry_set_completion((GtkEntry*)({* id *}), (GtkEntryCompletion*)({* property.value *}))"} },
    ["enable-emoji-completion"]       = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["extra-menu"]                    = {__type__="GMenuModel*"                                                      , __gencode__ = {"gtk_entry_set_extra_menu((GtkEntry*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["has-frame"]                     = {__type__="gboolean"            ,__default__ = "TRUE"                        , __gencode__ = {"gtk_entry_set_has_frame((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    ["im-module"]                     = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["input-hints"]                   = {__type__="GtkInputHints"                                                    , __gencode__ = {"gtk_entry_set_input_hints((GtkEntry*)({* id *}), (GtkInputHints)({* property.value *}))"} },
    ["input-purpose"]                 = {__type__="GtkInputPurpose"     ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" , __gencode__ = {"gtk_entry_set_input_purpose((GtkEntry*)({* id *}), (GtkInputPurpose)({* property.value *}))"} },
    ["invisible-char"]                = {__type__="guint"               ,__default__ = "'*'"                         , __gencode__ = {"gtk_entry_set_invisible_char((GtkEntry*)({* id *}), (gunichar)({* property.value *}))"} },
    ["invisible-char-set"]            = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["max-length"]                    = {__type__="gint"                ,__default__ = "0"                           , __gencode__ = {"gtk_entry_set_max_length((GtkEntry*)({* id *}), (int)({* property.value *}))"} },
    ["overwrite-mode"]                = {__type__="gboolean"            ,__default__ = "FALSE"                       , __gencode__ = {"gtk_entry_set_overwrite_mode((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    ["placeholder-text"]              = {__type__="gchar*"              ,__default__ = "NULL"                        , __gencode__ = {"gtk_entry_set_placeholder_text((GtkEntry*)({* id *}), (const char*)({* property.value *}))"} },
    ["primary-icon-activatable"]      = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["primary-icon-gicon"]            = {__type__="GIcon*"                                                           ,rwflags="rw" },
    ["primary-icon-name"]             = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["primary-icon-paintable"]        = {__type__="GdkPaintable*"                                                    ,rwflags="rw" },
    ["primary-icon-sensitive"]        = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["primary-icon-storage-type"]     = {__type__="GtkImageType"        ,__default__ = "GTK_IMAGE_EMPTY"              },
    ["primary-icon-tooltip-markup"]   = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["primary-icon-tooltip-text"]     = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["progress-fraction"]             = {__type__="gdouble"             ,__default__ = "0"                           , __gencode__ = {"gtk_entry_set_progress_fraction((GtkEntry*)({* id *}), (double)({* property.value *}))"} },
    ["progress-pulse-step"]           = {__type__="gdouble"             ,__default__ = "0"                           , __gencode__ = {"gtk_entry_set_progress_pulse_step((GtkEntry*)({* id *}), (double)({* property.value *}))"} },
    ["scroll-offset"]                 = {__type__="gint"                ,__default__ = "0"                            },
    ["secondary-icon-activatable"]    = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["secondary-icon-gicon"]          = {__type__="GIcon*"                                                           ,rwflags="rw" },
    ["secondary-icon-name"]           = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["secondary-icon-paintable"]      = {__type__="GdkPaintable*"                                                    ,rwflags="rw" },
    ["secondary-icon-sensitive"]      = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["secondary-icon-storage-type"]   = {__type__="GtkImageType"        ,__default__ = "GTK_IMAGE_EMPTY"              },
    ["secondary-icon-tooltip-markup"] = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["secondary-icon-tooltip-text"]   = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["show-emoji-icon"]               = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    tabs                              = {__type__="PangoTabArray*"                                                   , __gencode__ = {"gtk_entry_set_tabs((GtkEntry*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    ["text-length"]                   = {__type__="guint"               ,__default__ = "0"                            },
    ["truncate-multiline"]            = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    visibility                        = {__type__="gboolean"            ,__default__ = "TRUE"                        , __gencode__ = {"gtk_entry_set_visibility((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkCellEditable, Gtk418.GtkConstraintTarget, Gtk418.GtkEditable}, 
};

---------------------  GtkEventControllerFocus
Gtk418.GtkEventControllerFocus = {
  class = "GtkEventControllerFocus", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_focus_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    enter = {ret_type = "void", params = {type = {"GtkEventControllerFocus*"}, name ={"eventcontrollerfocus"}} }, 
    leave = {ret_type = "void", params = {type = {"GtkEventControllerFocus*"}, name ={"eventcontrollerfocus"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["contains-focus"] = {__type__="gboolean" ,__default__ = "FALSE"  },
    ["is-focus"]       = {__type__="gboolean" ,__default__ = "FALSE"  },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkEventControllerKey
Gtk418.GtkEventControllerKey = {
  class = "GtkEventControllerKey", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_key_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['im-update']    = {ret_type = "void"    , params = {type = {"GtkEventControllerKey*"}, name ={"eventcontrollerkey"}} }, 
    ['key-pressed']  = {ret_type = "gboolean", params = {type = {"GtkEventControllerKey*", "guint", "guint", "GdkModifierType*"}, name ={"eventcontrollerkey", "keyval", "keycode", "state"}} }, 
    ['key-released'] = {ret_type = "void"    , params = {type = {"GtkEventControllerKey*", "guint", "guint", "GdkModifierType*"}, name ={"eventcontrollerkey", "keyval", "keycode", "state"}} }, 
    modifiers        = {ret_type = "gboolean", params = {type = {"GtkEventControllerKey*", "GdkModifierType*"}, name ={"eventcontrollerkey", "state"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkEventControllerLegacy
Gtk418.GtkEventControllerLegacy = {
  class = "GtkEventControllerLegacy", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_legacy_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    event = {ret_type = "gboolean", params = {type = {"GtkEventControllerLegacy*", "GdkEvent*"}, name ={"eventcontrollerlegacy", "event"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkEventControllerMotion
Gtk418.GtkEventControllerMotion = {
  class = "GtkEventControllerMotion", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_motion_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    enter  = {ret_type = "void", params = {type = {"GtkEventControllerMotion*", "gdouble", "gdouble"}, name ={"eventcontrollermotion", "x", "y"}} }, 
    leave  = {ret_type = "void", params = {type = {"GtkEventControllerMotion*"}, name ={"eventcontrollermotion"}} }, 
    motion = {ret_type = "void", params = {type = {"GtkEventControllerMotion*", "gdouble", "gdouble"}, name ={"eventcontrollermotion", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["contains-pointer"] = {__type__="gboolean" ,__default__ = "FALSE"  },
    ["is-pointer"]       = {__type__="gboolean" ,__default__ = "FALSE"  },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkEventControllerScroll
Gtk418.GtkEventControllerScroll = {
  class = "GtkEventControllerScroll", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_scroll_new((GtkEventControllerScrollFlags)({* this.flags.value *}))", 
            params = { type = {"GtkEventControllerScrollFlags"}, 
                       name = {"flags"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    decelerate       = {ret_type = "void"    , params = {type = {"GtkEventControllerScroll*", "gdouble", "gdouble"}, name ={"eventcontrollerscroll", "vel_x", "vel_y"}} }, 
    scroll           = {ret_type = "gboolean", params = {type = {"GtkEventControllerScroll*", "gdouble", "gdouble"}, name ={"eventcontrollerscroll", "dx", "dy"}} }, 
    ['scroll-begin'] = {ret_type = "void"    , params = {type = {"GtkEventControllerScroll*"}, name ={"eventcontrollerscroll"}} }, 
    ['scroll-end']   = {ret_type = "void"    , params = {type = {"GtkEventControllerScroll*"}, name ={"eventcontrollerscroll"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    flags = {__type__="GtkEventControllerScrollFlags" , __gencode__ = {"gtk_event_controller_scroll_set_flags((GtkEventControllerScroll*)({* id *}), (GtkEventControllerScrollFlags)({* property.value *}))"} },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkExpander
Gtk418.GtkExpander = {
  class = "GtkExpander", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_expander_new((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_expander_new_with_mnemonic((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkExpander*"}, name ={"expander"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child               = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_expander_set_child((GtkExpander*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    expanded            = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_expanded((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    label               = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_expander_set_label((GtkExpander*)({* id *}), (const char*)({* property.value *}))"},__construct__= 1 },
    ["label-widget"]    = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_expander_set_label_widget((GtkExpander*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["resize-toplevel"] = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_resize_toplevel((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-markup"]      = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_use_markup((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["use-underline"]   = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_use_underline((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkFileChooserNative
Gtk418.GtkFileChooserNative = {
  class = "GtkFileChooserNative", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_chooser_native_new((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const char*)({* this['accept-label'].value *}), (const char*)({* this['cancel-label'].value *}))", 
            params = { type = {"const char*", "GtkFileChooserAction", "const char*", "const char*"}, 
                       name = {"title", "action", "accept-label", "cancel-label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-label"] = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_file_chooser_native_set_accept_label((GtkFileChooserNative*)({* id *}), (const char*)({* property.value *}))"} },
    ["cancel-label"] = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_file_chooser_native_set_cancel_label((GtkFileChooserNative*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkNativeDialog,
  implement = {Gtk418.GtkFileChooser}, 
};

---------------------  GtkFileChooserWidget
Gtk418.GtkFileChooserWidget = {
  class = "GtkFileChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_chooser_widget_new((GtkFileChooserAction)({* this.action.value *}))", 
            params = { type = {"GtkFileChooserAction"}, 
                       name = {"action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['desktop-folder']          = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['down-folder']             = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['home-folder']             = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['location-popup']          = {ret_type = "void", params = {type = {"GtkFileChooserWidget*", "gchar*"}, name ={"filechooserwidget", "path"}} }, 
    ['location-popup-on-paste'] = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['location-toggle-popup']   = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['places-shortcut']         = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['quick-bookmark']          = {ret_type = "void", params = {type = {"GtkFileChooserWidget*", "gint"}, name ={"filechooserwidget", "bookmark_index"}} }, 
    ['recent-shortcut']         = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['search-shortcut']         = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['show-hidden']             = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['up-folder']               = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["search-mode"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    ["show-time"]   = {__type__="gboolean" ,__default__ = "FALSE"  },
    subtitle        = {__type__="gchar*"   ,__default__ = "\"\""   },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkFileChooser}, 
};

---------------------  GtkFileFilter
Gtk418.GtkFileFilter = {
  class = "GtkFileFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_file_filter_new()", 
            params = { type = {}, name = {} } },
    new_from_gvariant = { gencode = "gtk_file_filter_new_from_gvariant((GVariant*)({* this.variant.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["mime-types"] = {__type__="GStrv"                        ,rwflags="w" },
    name           = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_file_filter_set_name((GtkFileFilter*)({* id *}), (const char*)({* property.value *}))"} },
    patterns       = {__type__="GStrv"                        ,rwflags="w" },
    suffixes       = {__type__="GStrv"                        ,rwflags="w" },
  },
  parent = Gtk418.GtkFilter,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkFixed
Gtk418.GtkFixed = {
  class = "GtkFixed", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_fixed_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkFixedLayout
Gtk418.GtkFixedLayout = {
  class = "GtkFixedLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_fixed_layout_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkLayoutManager,
};

---------------------  GtkFixedLayoutChild
Gtk418.GtkFixedLayoutChild = {
  class = "GtkFixedLayoutChild", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    transform = {__type__="GskTransform*" , __gencode__ = {"gtk_fixed_layout_child_set_transform((GtkFixedLayoutChild*)({* id *}), (GskTransform*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkLayoutChild,
};

---------------------  GtkFlowBox
Gtk418.GtkFlowBox = {
  class = "GtkFlowBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_flow_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-child']     = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['child-activated']           = {ret_type = "void"    , params = {type = {"GtkFlowBox*", "GtkFlowBoxChild*"}, name ={"flowbox", "child"}} }, 
    ['move-cursor']               = {ret_type = "gboolean", params = {type = {"GtkFlowBox*", "GtkMovementStep", "gint", "gboolean", "gboolean"}, name ={"flowbox", "step", "count", "extend", "modify"}} }, 
    ['select-all']                = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['selected-children-changed'] = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['toggle-cursor-child']       = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['unselect-all']              = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-unpaired-release"]  = {__type__="gboolean"         ,__default__ = "FALSE"                ,rwflags="rw" },
    ["activate-on-single-click"] = {__type__="gboolean"         ,__default__ = "TRUE"                 , __gencode__ = {"gtk_flow_box_set_activate_on_single_click((GtkFlowBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["column-spacing"]           = {__type__="guint"            ,__default__ = "0"                    , __gencode__ = {"gtk_flow_box_set_column_spacing((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    homogeneous                  = {__type__="gboolean"         ,__default__ = "FALSE"                , __gencode__ = {"gtk_flow_box_set_homogeneous((GtkFlowBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-children-per-line"]    = {__type__="guint"            ,__default__ = "7"                    , __gencode__ = {"gtk_flow_box_set_max_children_per_line((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    ["min-children-per-line"]    = {__type__="guint"            ,__default__ = "0"                    , __gencode__ = {"gtk_flow_box_set_min_children_per_line((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    ["row-spacing"]              = {__type__="guint"            ,__default__ = "0"                    , __gencode__ = {"gtk_flow_box_set_row_spacing((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    ["selection-mode"]           = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE" , __gencode__ = {"gtk_flow_box_set_selection_mode((GtkFlowBox*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkFlowBoxChild
Gtk418.GtkFlowBoxChild = {
  class = "GtkFlowBoxChild", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_flow_box_child_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkFlowBoxChild*"}, {"child"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkFlowBoxChild*"}, name ={"child"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child = {__type__="GtkWidget*" , __gencode__ = {"gtk_flow_box_child_set_child((GtkFlowBoxChild*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkFontButton
Gtk418.GtkFontButton = {
  class = "GtkFontButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_font_button_new()", 
            params = { type = {}, name = {} } },
    new_with_font = { gencode = "gtk_font_button_new_with_font((const char*)({* this.fontname.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate     = {ret_type = "void", params = {type = {"GtkFontButton*"}, name ={"fontbutton"}} }, 
    ['font-set'] = {ret_type = "void", params = {type = {"GtkFontButton*"}, name ={"fontbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    modal        = {__type__="gboolean" ,__default__ = "TRUE"            , __gencode__ = {"gtk_font_button_set_modal((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    title        = {__type__="gchar*"   ,__default__ = "\"Pick a Font\"" , __gencode__ = {"gtk_font_button_set_title((GtkFontButton*)({* id *}), (const char*)({* property.value *}))"} },
    ["use-font"] = {__type__="gboolean" ,__default__ = "FALSE"           , __gencode__ = {"gtk_font_button_set_use_font((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-size"] = {__type__="gboolean" ,__default__ = "FALSE"           , __gencode__ = {"gtk_font_button_set_use_size((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkFontChooser}, 
};

---------------------  GtkFontChooserWidget
Gtk418.GtkFontChooserWidget = {
  class = "GtkFontChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_chooser_widget_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["tweak-action"] = {__type__="GAction*"  },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkFontChooser}, 
};

---------------------  GtkFontDialogButton
Gtk418.GtkFontDialogButton = {
  class = "GtkFontDialogButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_dialog_button_new((GtkFontDialog*)({* this.dialog.value *}))", 
            params = { type = {"GtkFontDialog*"}, 
                       name = {"dialog"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkFontDialogButton*"}, name ={"fontdialogbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    dialog            = {__type__="GtkFontDialog*"                                             , __gencode__ = {"gtk_font_dialog_button_set_dialog((GtkFontDialogButton*)({* id *}), (GtkFontDialog*)({* property.value *}))"} },
    ["font-desc"]     = {__type__="PangoFontDescription*"                                      , __gencode__ = {"gtk_font_dialog_button_set_font_desc((GtkFontDialogButton*)({* id *}), (const PangoFontDescription*)({* property.value *}))"} },
    ["font-features"] = {__type__="gchar*"                ,__default__ = "NULL"                , __gencode__ = {"gtk_font_dialog_button_set_font_features((GtkFontDialogButton*)({* id *}), (const char*)({* property.value *}))"} },
    language          = {__type__="PangoLanguage*"                                             , __gencode__ = {"gtk_font_dialog_button_set_language((GtkFontDialogButton*)({* id *}), (PangoLanguage*)({* property.value *}))"} },
    level             = {__type__="GtkFontLevel"          ,__default__ = "GTK_FONT_LEVEL_FONT" , __gencode__ = {"gtk_font_dialog_button_set_level((GtkFontDialogButton*)({* id *}), (GtkFontLevel)({* property.value *}))"} },
    ["use-font"]      = {__type__="gboolean"              ,__default__ = "FALSE"               , __gencode__ = {"gtk_font_dialog_button_set_use_font((GtkFontDialogButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-size"]      = {__type__="gboolean"              ,__default__ = "FALSE"               , __gencode__ = {"gtk_font_dialog_button_set_use_size((GtkFontDialogButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkFrame
Gtk418.GtkFrame = {
  class = "GtkFrame", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_frame_new((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    compute_child_allocation = {"void", {"GtkFrame*", "GtkAllocation*"}, {"frame", "allocation"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child            = {__type__="GtkWidget*"                       , __gencode__ = {"gtk_frame_set_child((GtkFrame*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    label            = {__type__="gchar*"     ,__default__ = "NULL" , __gencode__ = {"gtk_frame_set_label((GtkFrame*)({* id *}), (const char*)({* property.value *}))"} },
    ["label-widget"] = {__type__="GtkWidget*"                       , __gencode__ = {"gtk_frame_set_label_widget((GtkFrame*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["label-xalign"] = {__type__="gfloat"     ,__default__ = "0"    ,rwflags="rw" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkGLArea
Gtk418.GtkGLArea = {
  class = "GtkGLArea", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gl_area_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_context = {"GdkGLContext*", {"GtkGLArea*"}, {"area"} }, 
    render         = {"gboolean"     , {"GtkGLArea*", "GdkGLContext*"}, {"area", "context"} }, 
    resize         = {"void"         , {"GtkGLArea*", "int", "int"}, {"area", "width", "height"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['create-context'] = {ret_type = "{Gdk.GLContext}", params = {type = {"GtkGLArea*"}, name ={"glarea"}} }, 
    render             = {ret_type = "gboolean"       , params = {type = {"GtkGLArea*", "GdkGLContext*"}, name ={"area", "context"}} }, 
    resize             = {ret_type = "void"           , params = {type = {"GtkGLArea*", "int", "int"}, name ={"area", "width", "height"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["allowed-apis"]       = {__type__="GdkGLAPI"      ,__default__ = "GDK_GL_API_GL | GDK_GL_API_GLES" , __gencode__ = {"gtk_gl_area_set_allowed_apis((GtkGLArea*)({* id *}), (GdkGLAPI)({* property.value *}))"} },
    api                    = {__type__="GdkGLAPI"                                                        },
    ["auto-render"]        = {__type__="gboolean"      ,__default__ = "TRUE"                            , __gencode__ = {"gtk_gl_area_set_auto_render((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    context                = {__type__="GdkGLContext*"                                                   },
    ["has-depth-buffer"]   = {__type__="gboolean"      ,__default__ = "FALSE"                           , __gencode__ = {"gtk_gl_area_set_has_depth_buffer((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-stencil-buffer"] = {__type__="gboolean"      ,__default__ = "FALSE"                           , __gencode__ = {"gtk_gl_area_set_has_stencil_buffer((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-es"]             = {__type__="gboolean"      ,__default__ = "FALSE"                           , __gencode__ = {"gtk_gl_area_set_use_es((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkGesture
Gtk418.GtkGesture = {
  class = "GtkGesture", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    begin                      = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
    cancel                     = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
    ['end']                    = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
    ['sequence-state-changed'] = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*", "GtkEventSequenceState"}, name ={"gesture", "sequence", "state"}} }, 
    update                     = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["n-points"] = {__type__="guint" ,__default__ = "1" ,rwflags="rw" },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkGraphicsOffload
Gtk418.GtkGraphicsOffload = {
  class = "GtkGraphicsOffload", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_graphics_offload_new((GtkWidget*)({* this.child.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["black-background"] = {__type__="gboolean"                  ,__default__ = "FALSE"                        , __gencode__ = {"gtk_graphics_offload_set_black_background((GtkGraphicsOffload*)({* id *}), (gboolean)({* property.value *}))"} },
    child                = {__type__="GtkWidget*"                                                              , __gencode__ = {"gtk_graphics_offload_set_child((GtkGraphicsOffload*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    enabled              = {__type__="GtkGraphicsOffloadEnabled" ,__default__ = "GTK_GRAPHICS_OFFLOAD_ENABLED" , __gencode__ = {"gtk_graphics_offload_set_enabled((GtkGraphicsOffload*)({* id *}), (GtkGraphicsOffloadEnabled)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkGrid
Gtk418.GtkGrid = {
  class = "GtkGrid", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_grid_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-row"]       = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_set_baseline_row((GtkGrid*)({* id *}), (int)({* property.value *}))"} },
    ["column-homogeneous"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_grid_set_column_homogeneous((GtkGrid*)({* id *}), (gboolean)({* property.value *}))"} },
    ["column-spacing"]     = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_set_column_spacing((GtkGrid*)({* id *}), (guint)({* property.value *}))"} },
    ["row-homogeneous"]    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_grid_set_row_homogeneous((GtkGrid*)({* id *}), (gboolean)({* property.value *}))"} },
    ["row-spacing"]        = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_set_row_spacing((GtkGrid*)({* id *}), (guint)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkGridLayout
Gtk418.GtkGridLayout = {
  class = "GtkGridLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_grid_layout_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-row"]       = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_layout_set_baseline_row((GtkGridLayout*)({* id *}), (int)({* property.value *}))"} },
    ["column-homogeneous"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_grid_layout_set_column_homogeneous((GtkGridLayout*)({* id *}), (gboolean)({* property.value *}))"} },
    ["column-spacing"]     = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_layout_set_column_spacing((GtkGridLayout*)({* id *}), (guint)({* property.value *}))"} },
    ["row-homogeneous"]    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_grid_layout_set_row_homogeneous((GtkGridLayout*)({* id *}), (gboolean)({* property.value *}))"} },
    ["row-spacing"]        = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_layout_set_row_spacing((GtkGridLayout*)({* id *}), (guint)({* property.value *}))"} },
  },
  parent = Gtk418.GtkLayoutManager,
};

---------------------  GtkGridLayoutChild
Gtk418.GtkGridLayoutChild = {
  class = "GtkGridLayoutChild", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    column          = {__type__="gint" ,__default__ = "0" , __gencode__ = {"gtk_grid_layout_child_set_column((GtkGridLayoutChild*)({* id *}), (int)({* property.value *}))"} },
    ["column-span"] = {__type__="gint" ,__default__ = "1" , __gencode__ = {"gtk_grid_layout_child_set_column_span((GtkGridLayoutChild*)({* id *}), (int)({* property.value *}))"} },
    row             = {__type__="gint" ,__default__ = "0" , __gencode__ = {"gtk_grid_layout_child_set_row((GtkGridLayoutChild*)({* id *}), (int)({* property.value *}))"} },
    ["row-span"]    = {__type__="gint" ,__default__ = "1" , __gencode__ = {"gtk_grid_layout_child_set_row_span((GtkGridLayoutChild*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = Gtk418.GtkLayoutChild,
};

---------------------  GtkHeaderBar
Gtk418.GtkHeaderBar = {
  class = "GtkHeaderBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_header_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["decoration-layout"]   = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_header_bar_set_decoration_layout((GtkHeaderBar*)({* id *}), (const char*)({* property.value *}))"} },
    ["show-title-buttons"]  = {__type__="gboolean"   ,__default__ = "TRUE"  , __gencode__ = {"gtk_header_bar_set_show_title_buttons((GtkHeaderBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["title-widget"]        = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_header_bar_set_title_widget((GtkHeaderBar*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["use-native-controls"] = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_header_bar_set_use_native_controls((GtkHeaderBar*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkIMContextSimple
Gtk418.GtkIMContextSimple = {
  class = "GtkIMContextSimple", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_im_context_simple_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkIMContext,
};

---------------------  GtkIMMulticontext
Gtk418.GtkIMMulticontext = {
  class = "GtkIMMulticontext", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_im_multicontext_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkIMContext,
};

---------------------  GtkIconView
Gtk418.GtkIconView = {
  class = "GtkIconView", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_icon_view_new()", 
            params = { type = {}, name = {} } },
    new_with_area  = { gencode = "gtk_icon_view_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_icon_view_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-item'] = {ret_type = "gboolean", params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['item-activated']       = {ret_type = "void"    , params = {type = {"GtkIconView*", "GtkTreePath*"}, name ={"iconview", "path"}} }, 
    ['move-cursor']          = {ret_type = "gboolean", params = {type = {"GtkIconView*", "GtkMovementStep", "gint", "gboolean", "gboolean"}, name ={"iconview", "step", "count", "extend", "modify"}} }, 
    ['select-all']           = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['select-cursor-item']   = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['selection-changed']    = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['toggle-cursor-item']   = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['unselect-all']         = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activate-on-single-click"] = {__type__="gboolean"         ,__default__ = "FALSE"                    , __gencode__ = {"gtk_icon_view_set_activate_on_single_click((GtkIconView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["cell-area"]                = {__type__="GtkCellArea*"                                               ,rwflags="rw" },
    ["column-spacing"]           = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_column_spacing((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    columns                      = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_columns((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    ["item-orientation"]         = {__type__="GtkOrientation"   ,__default__ = "GTK_ORIENTATION_VERTICAL" , __gencode__ = {"gtk_icon_view_set_item_orientation((GtkIconView*)({* id *}), (GtkOrientation)({* property.value *}))"} },
    ["item-padding"]             = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_item_padding((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    ["item-width"]               = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_item_width((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    margin                       = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_margin((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    ["markup-column"]            = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_markup_column((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    model                        = {__type__="GtkTreeModel*"                                              , __gencode__ = {"gtk_icon_view_set_model((GtkIconView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    ["pixbuf-column"]            = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_pixbuf_column((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    reorderable                  = {__type__="gboolean"         ,__default__ = "FALSE"                    , __gencode__ = {"gtk_icon_view_set_reorderable((GtkIconView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["row-spacing"]              = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_row_spacing((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    ["selection-mode"]           = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE"     , __gencode__ = {"gtk_icon_view_set_selection_mode((GtkIconView*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
    spacing                      = {__type__="gint"             ,__default__ = "0"                        , __gencode__ = {"gtk_icon_view_set_spacing((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    ["text-column"]              = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_text_column((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
    ["tooltip-column"]           = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_tooltip_column((GtkIconView*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkCellLayout, Gtk418.GtkConstraintTarget, Gtk418.GtkScrollable}, 
};

---------------------  GtkImage
Gtk418.GtkImage = {
  class = "GtkImage", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_image_new()", 
            params = { type = {}, name = {} } },
    new_from_file      = { gencode = "gtk_image_new_from_file((const char*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gicon     = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this.icon.value *}))", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_image_new_from_icon_name((const char*)({* this['icon-name']value *}))", 
            params = { type = {"const char*"}, 
                       name = {"icon-name"} } },
    new_from_paintable = { gencode = "gtk_image_new_from_paintable((GdkPaintable*)({* this.paintable.value *}))", 
            params = { type = {"GdkPaintable*"}, 
                       name = {"paintable"} } },
    new_from_pixbuf    = { gencode = "gtk_image_new_from_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {}, name = {} } },
    new_from_resource  = { gencode = "gtk_image_new_from_resource((const char*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    file             = {__type__="gchar*"        ,__default__ = "NULL"                  , __gencode__ = {"gtk_image_set_from_file((GtkImage*)({* id *}), (const char*)({* property.value *}))"} },
    gicon            = {__type__="GIcon*"                                               , __gencode__ = {"gtk_image_set_from_gicon((GtkImage*)({* id *}), (GIcon*)({* property.value *}))"} },
    ["icon-name"]    = {__type__="gchar*"        ,__default__ = "NULL"                  , __gencode__ = {"gtk_image_set_from_icon_name((GtkImage*)({* id *}), (const char*)({* property.value *}))"} },
    ["icon-size"]    = {__type__="GtkIconSize"   ,__default__ = "GTK_ICON_SIZE_INHERIT" , __gencode__ = {"gtk_image_set_icon_size((GtkImage*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    paintable        = {__type__="GdkPaintable*"                                        , __gencode__ = {"gtk_image_set_from_paintable((GtkImage*)({* id *}), (GdkPaintable*)({* property.value *}))"} },
    ["pixel-size"]   = {__type__="gint"          ,__default__ = "-1"                    , __gencode__ = {"gtk_image_set_pixel_size((GtkImage*)({* id *}), (int)({* property.value *}))"} },
    resource         = {__type__="gchar*"        ,__default__ = "NULL"                  , __gencode__ = {"gtk_image_set_from_resource((GtkImage*)({* id *}), (const char*)({* property.value *}))"} },
    ["storage-type"] = {__type__="GtkImageType"  ,__default__ = "GTK_IMAGE_EMPTY"        },
    ["use-fallback"] = {__type__="gboolean"      ,__default__ = "FALSE"                 ,rwflags="rw" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkInfoBar
Gtk418.GtkInfoBar = {
  class = "GtkInfoBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_info_bar_new()", 
            params = { type = {}, name = {} } },
    new_with_buttons = { gencode = "gtk_info_bar_new_with_buttons((const char*)({* this.first_button_text.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close    = {ret_type = "void", params = {type = {"GtkInfoBar*"}, name ={"infobar"}} }, 
    response = {ret_type = "void", params = {type = {"GtkInfoBar*", "gint"}, name ={"infobar", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["message-type"]      = {__type__="GtkMessageType" ,__default__ = "GTK_MESSAGE_INFO" , __gencode__ = {"gtk_info_bar_set_message_type((GtkInfoBar*)({* id *}), (GtkMessageType)({* property.value *}))"},__construct__= 1 },
    revealed              = {__type__="gboolean"       ,__default__ = "TRUE"             , __gencode__ = {"gtk_info_bar_set_revealed((GtkInfoBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-close-button"] = {__type__="gboolean"       ,__default__ = "FALSE"            , __gencode__ = {"gtk_info_bar_set_show_close_button((GtkInfoBar*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkInscription
Gtk418.GtkInscription = {
  class = "GtkInscription", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_inscription_new((const char*)({* this.text.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"text"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    attributes        = {__type__="PangoAttrList*"                                                        , __gencode__ = {"gtk_inscription_set_attributes((GtkInscription*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    markup            = {__type__="gchar*"                 ,__default__ = "NULL"                          , __gencode__ = {"gtk_inscription_set_markup((GtkInscription*)({* id *}), (const char*)({* property.value *}))"} },
    ["min-chars"]     = {__type__="guint"                  ,__default__ = "3"                             , __gencode__ = {"gtk_inscription_set_min_chars((GtkInscription*)({* id *}), (guint)({* property.value *}))"} },
    ["min-lines"]     = {__type__="guint"                  ,__default__ = "1"                             , __gencode__ = {"gtk_inscription_set_min_lines((GtkInscription*)({* id *}), (guint)({* property.value *}))"} },
    ["nat-chars"]     = {__type__="guint"                  ,__default__ = "0"                             , __gencode__ = {"gtk_inscription_set_nat_chars((GtkInscription*)({* id *}), (guint)({* property.value *}))"} },
    ["nat-lines"]     = {__type__="guint"                  ,__default__ = "0"                             , __gencode__ = {"gtk_inscription_set_nat_lines((GtkInscription*)({* id *}), (guint)({* property.value *}))"} },
    text              = {__type__="gchar*"                 ,__default__ = "NULL"                          , __gencode__ = {"gtk_inscription_set_text((GtkInscription*)({* id *}), (const char*)({* property.value *}))"} },
    ["text-overflow"] = {__type__="GtkInscriptionOverflow" ,__default__ = "GTK_INSCRIPTION_OVERFLOW_CLIP" , __gencode__ = {"gtk_inscription_set_text_overflow((GtkInscription*)({* id *}), (GtkInscriptionOverflow)({* property.value *}))"} },
    ["wrap-mode"]     = {__type__="PangoWrapMode"          ,__default__ = "PANGO_WRAP_WORD_CHAR"          , __gencode__ = {"gtk_inscription_set_wrap_mode((GtkInscription*)({* id *}), (PangoWrapMode)({* property.value *}))"} },
    xalign            = {__type__="gfloat"                 ,__default__ = "0"                             , __gencode__ = {"gtk_inscription_set_xalign((GtkInscription*)({* id *}), (float)({* property.value *}))"} },
    yalign            = {__type__="gfloat"                 ,__default__ = "0.5"                           , __gencode__ = {"gtk_inscription_set_yalign((GtkInscription*)({* id *}), (float)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleText, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkKeyvalTrigger
Gtk418.GtkKeyvalTrigger = {
  class = "GtkKeyvalTrigger", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_keyval_trigger_new((guint)({* this.keyval.value *}), (GdkModifierType)({* this.modifiers.value *}))", 
            params = { type = {"guint", "GdkModifierType"}, 
                       name = {"keyval", "modifiers"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    keyval    = {__type__="guint"            ,__default__ = "0" ,rwflags="rw" },
    modifiers = {__type__="GdkModifierType*"                    ,rwflags="rw" },
  },
  parent = Gtk418.GtkShortcutTrigger,
};

---------------------  GtkLabel
Gtk418.GtkLabel = {
  class = "GtkLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_label_new((const char*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
    new_with_mnemonic = { gencode = "gtk_label_new_with_mnemonic((const char*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-current-link'] = {ret_type = "void"    , params = {type = {"GtkLabel*"}, name ={"label"}} }, 
    ['activate-link']         = {ret_type = "gboolean", params = {type = {"GtkLabel*", "gchar*"}, name ={"label", "uri"}} }, 
    ['copy-clipboard']        = {ret_type = "void"    , params = {type = {"GtkLabel*"}, name ={"label"}} }, 
    ['move-cursor']           = {ret_type = "void"    , params = {type = {"GtkLabel*", "GtkMovementStep", "gint", "gboolean"}, name ={"label", "step", "count", "extend_selection"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    attributes            = {__type__="PangoAttrList*"                                               , __gencode__ = {"gtk_label_set_attributes((GtkLabel*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    ellipsize             = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE"     , __gencode__ = {"gtk_label_set_ellipsize((GtkLabel*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    ["extra-menu"]        = {__type__="GMenuModel*"                                                  , __gencode__ = {"gtk_label_set_extra_menu((GtkLabel*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    justify               = {__type__="GtkJustification"   ,__default__ = "GTK_JUSTIFY_LEFT"         , __gencode__ = {"gtk_label_set_justify((GtkLabel*)({* id *}), (GtkJustification)({* property.value *}))"} },
    label                 = {__type__="gchar*"             ,__default__ = "\"\""                     , __gencode__ = {"gtk_label_set_label((GtkLabel*)({* id *}), (const char*)({* property.value *}))"} },
    lines                 = {__type__="gint"               ,__default__ = "-1"                       , __gencode__ = {"gtk_label_set_lines((GtkLabel*)({* id *}), (int)({* property.value *}))"} },
    ["max-width-chars"]   = {__type__="gint"               ,__default__ = "-1"                       , __gencode__ = {"gtk_label_set_max_width_chars((GtkLabel*)({* id *}), (int)({* property.value *}))"} },
    ["mnemonic-keyval"]   = {__type__="guint"              ,__default__ = "16777215"                  },
    ["mnemonic-widget"]   = {__type__="GtkWidget*"                                                   , __gencode__ = {"gtk_label_set_mnemonic_widget((GtkLabel*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["natural-wrap-mode"] = {__type__="GtkNaturalWrapMode" ,__default__ = "GTK_NATURAL_WRAP_INHERIT" , __gencode__ = {"gtk_label_set_natural_wrap_mode((GtkLabel*)({* id *}), (GtkNaturalWrapMode)({* property.value *}))"} },
    selectable            = {__type__="gboolean"           ,__default__ = "FALSE"                    , __gencode__ = {"gtk_label_set_selectable((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["single-line-mode"]  = {__type__="gboolean"           ,__default__ = "FALSE"                    , __gencode__ = {"gtk_label_set_single_line_mode((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    tabs                  = {__type__="PangoTabArray*"                                               , __gencode__ = {"gtk_label_set_tabs((GtkLabel*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    ["use-markup"]        = {__type__="gboolean"           ,__default__ = "FALSE"                    , __gencode__ = {"gtk_label_set_use_markup((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-underline"]     = {__type__="gboolean"           ,__default__ = "FALSE"                    , __gencode__ = {"gtk_label_set_use_underline((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["width-chars"]       = {__type__="gint"               ,__default__ = "-1"                       , __gencode__ = {"gtk_label_set_width_chars((GtkLabel*)({* id *}), (int)({* property.value *}))"} },
    wrap                  = {__type__="gboolean"           ,__default__ = "FALSE"                    , __gencode__ = {"gtk_label_set_wrap((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["wrap-mode"]         = {__type__="PangoWrapMode"      ,__default__ = "PANGO_WRAP_WORD"          , __gencode__ = {"gtk_label_set_wrap_mode((GtkLabel*)({* id *}), (PangoWrapMode)({* property.value *}))"} },
    xalign                = {__type__="gfloat"             ,__default__ = "0.5"                      , __gencode__ = {"gtk_label_set_xalign((GtkLabel*)({* id *}), (float)({* property.value *}))"} },
    yalign                = {__type__="gfloat"             ,__default__ = "0.5"                      , __gencode__ = {"gtk_label_set_yalign((GtkLabel*)({* id *}), (float)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleText, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkLevelBar
Gtk418.GtkLevelBar = {
  class = "GtkLevelBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_level_bar_new()", 
            params = { type = {}, name = {} } },
    new_for_interval = { gencode = "gtk_level_bar_new_for_interval((double)({* this['min-value']value *}), (double)({* this['max-value'].value *}))", 
            params = { type = {"double", "double"}, 
                       name = {"min-value", "max-value"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['offset-changed'] = {ret_type = "void", params = {type = {"GtkLevelBar*", "gchar*"}, name ={"levelbar", "name"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    inverted      = {__type__="gboolean"        ,__default__ = "FALSE"                         , __gencode__ = {"gtk_level_bar_set_inverted((GtkLevelBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-value"] = {__type__="gdouble"         ,__default__ = "1"                             , __gencode__ = {"gtk_level_bar_set_max_value((GtkLevelBar*)({* id *}), (double)({* property.value *}))"} },
    ["min-value"] = {__type__="gdouble"         ,__default__ = "0"                             , __gencode__ = {"gtk_level_bar_set_min_value((GtkLevelBar*)({* id *}), (double)({* property.value *}))"} },
    mode          = {__type__="GtkLevelBarMode" ,__default__ = "GTK_LEVEL_BAR_MODE_CONTINUOUS" , __gencode__ = {"gtk_level_bar_set_mode((GtkLevelBar*)({* id *}), (GtkLevelBarMode)({* property.value *}))"} },
    value         = {__type__="gdouble"         ,__default__ = "0"                             , __gencode__ = {"gtk_level_bar_set_value((GtkLevelBar*)({* id *}), (double)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkListBase
Gtk418.GtkListBase = {
  class = "GtkListBase", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_VERTICAL" ,rwflags="rw" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable, Gtk418.GtkScrollable}, 
};

---------------------  GtkListBox
Gtk418.GtkListBox = {
  class = "GtkListBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_list_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-row']   = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['move-cursor']           = {ret_type = "void", params = {type = {"GtkListBox*", "GtkMovementStep", "gint", "gboolean", "gboolean"}, name ={"listbox", "step", "count", "extend", "modify"}} }, 
    ['row-activated']         = {ret_type = "void", params = {type = {"GtkListBox*", "GtkListBoxRow*"}, name ={"listbox", "row"}} }, 
    ['row-selected']          = {ret_type = "void", params = {type = {"GtkListBox*", "GtkListBoxRow*"}, name ={"listbox", "row"}} }, 
    ['select-all']            = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['selected-rows-changed'] = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['toggle-cursor-row']     = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['unselect-all']          = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-unpaired-release"]  = {__type__="gboolean"           ,__default__ = "FALSE"                ,rwflags="rw" },
    ["activate-on-single-click"] = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_list_box_set_activate_on_single_click((GtkListBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["selection-mode"]           = {__type__="GtkSelectionMode"   ,__default__ = "GTK_SELECTION_SINGLE" , __gencode__ = {"gtk_list_box_set_selection_mode((GtkListBox*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
    ["show-separators"]          = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_list_box_set_show_separators((GtkListBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tab-behavior"]             = {__type__="GtkListTabBehavior" ,__default__ = "GTK_LIST_TAB_ALL"     , __gencode__ = {"gtk_list_box_set_tab_behavior((GtkListBox*)({* id *}), (GtkListTabBehavior)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkListBoxRow
Gtk418.GtkListBoxRow = {
  class = "GtkListBoxRow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_list_box_row_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkListBoxRow*"}, {"row"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkListBoxRow*"}, name ={"row"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activatable = {__type__="gboolean"   ,__default__ = "TRUE" , __gencode__ = {"gtk_list_box_row_set_activatable((GtkListBoxRow*)({* id *}), (gboolean)({* property.value *}))"} },
    child       = {__type__="GtkWidget*"                       , __gencode__ = {"gtk_list_box_row_set_child((GtkListBoxRow*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    selectable  = {__type__="gboolean"   ,__default__ = "TRUE" , __gencode__ = {"gtk_list_box_row_set_selectable((GtkListBoxRow*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkMediaControls
Gtk418.GtkMediaControls = {
  class = "GtkMediaControls", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_media_controls_new((GtkMediaStream*)({* this.stream.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["media-stream"] = {__type__="GtkMediaStream*" , __gencode__ = {"gtk_media_controls_set_media_stream((GtkMediaControls*)({* id *}), (GtkMediaStream*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkMediaFile
Gtk418.GtkMediaFile = {
  class = "GtkMediaFile", 
  constructor = { 
    -- 名称[- ==> _], 
    new                  = { gencode = "gtk_media_file_new()", 
            params = { type = {}, name = {} } },
    new_for_file         = { gencode = "gtk_media_file_new_for_file((GFile*)({* this.file.value *}))", 
            params = { type = {"GFile*"}, 
                       name = {"file"} } },
    new_for_filename     = { gencode = "gtk_media_file_new_for_filename((const char*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_for_input_stream = { gencode = "gtk_media_file_new_for_input_stream((GInputStream*)({* this.stream.value *}))", 
            params = { type = {}, name = {} } },
    new_for_resource     = { gencode = "gtk_media_file_new_for_resource((const char*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close = {"void", {"GtkMediaFile*"}, {"self"} }, 
    open  = {"void", {"GtkMediaFile*"}, {"self"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    file             = {__type__="GFile*"        , __gencode__ = {"gtk_media_file_set_file((GtkMediaFile*)({* id *}), (GFile*)({* property.value *}))"} },
    ["input-stream"] = {__type__="GInputStream*" , __gencode__ = {"gtk_media_file_set_input_stream((GtkMediaFile*)({* id *}), (GInputStream*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkMediaStream,
};

---------------------  GtkMenuButton
Gtk418.GtkMenuButton = {
  class = "GtkMenuButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_menu_button_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkMenuButton*"}, name ={"menubutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active                = {__type__="gboolean"     ,__default__ = "FALSE"          , __gencode__ = {"gtk_menu_button_set_active((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["always-show-arrow"] = {__type__="gboolean"     ,__default__ = "FALSE"          , __gencode__ = {"gtk_menu_button_set_always_show_arrow((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["can-shrink"]        = {__type__="gboolean"     ,__default__ = "FALSE"          , __gencode__ = {"gtk_menu_button_set_can_shrink((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
    child                 = {__type__="GtkWidget*"                                   , __gencode__ = {"gtk_menu_button_set_child((GtkMenuButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    direction             = {__type__="GtkArrowType" ,__default__ = "GTK_ARROW_DOWN" , __gencode__ = {"gtk_menu_button_set_direction((GtkMenuButton*)({* id *}), (GtkArrowType)({* property.value *}))"} },
    ["has-frame"]         = {__type__="gboolean"     ,__default__ = "TRUE"           , __gencode__ = {"gtk_menu_button_set_has_frame((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["icon-name"]         = {__type__="gchar*"       ,__default__ = "NULL"           , __gencode__ = {"gtk_menu_button_set_icon_name((GtkMenuButton*)({* id *}), (const char*)({* property.value *}))"} },
    label                 = {__type__="gchar*"       ,__default__ = "NULL"           , __gencode__ = {"gtk_menu_button_set_label((GtkMenuButton*)({* id *}), (const char*)({* property.value *}))"} },
    ["menu-model"]        = {__type__="GMenuModel*"                                  , __gencode__ = {"gtk_menu_button_set_menu_model((GtkMenuButton*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    popover               = {__type__="GtkPopover*"                                  , __gencode__ = {"gtk_menu_button_set_popover((GtkMenuButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    primary               = {__type__="gboolean"     ,__default__ = "FALSE"          , __gencode__ = {"gtk_menu_button_set_primary((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-underline"]     = {__type__="gboolean"     ,__default__ = "FALSE"          , __gencode__ = {"gtk_menu_button_set_use_underline((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkMnemonicAction
Gtk418.GtkMnemonicAction = {
  class = "GtkMnemonicAction", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkShortcutAction,
};

---------------------  GtkMnemonicTrigger
Gtk418.GtkMnemonicTrigger = {
  class = "GtkMnemonicTrigger", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_mnemonic_trigger_new((guint)({* this.keyval.value *}))", 
            params = { type = {"guint"}, 
                       name = {"keyval"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    keyval = {__type__="guint" ,__default__ = "0" ,rwflags="rw" },
  },
  parent = Gtk418.GtkShortcutTrigger,
};

---------------------  GtkMultiFilter
Gtk418.GtkMultiFilter = {
  class = "GtkMultiFilter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                     },
    ["n-items"]   = {__type__="guint" ,__default__ = "0"  },
  },
  parent = Gtk418.GtkFilter,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkMultiSorter
Gtk418.GtkMultiSorter = {
  class = "GtkMultiSorter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_multi_sorter_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"] = {__type__="GType"                     },
    ["n-items"]   = {__type__="guint" ,__default__ = "0"  },
  },
  parent = Gtk418.GtkSorter,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkNamedAction
Gtk418.GtkNamedAction = {
  class = "GtkNamedAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_named_action_new((const char*)({* this.name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["action-name"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk418.GtkShortcutAction,
};

---------------------  GtkNeverTrigger
Gtk418.GtkNeverTrigger = {
  class = "GtkNeverTrigger", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkShortcutTrigger,
};

---------------------  GtkNotebook
Gtk418.GtkNotebook = {
  class = "GtkNotebook", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_notebook_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-current-page'] = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "gint"}, name ={"notebook", "page"}} }, 
    ['create-window']       = {ret_type = "{Notebook}", params = {type = {"GtkNotebook*", "GtkWidget*"}, name ={"notebook", "page"}} }, 
    ['focus-tab']           = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "GtkNotebookTab"}, name ={"notebook", "tab"}} }, 
    ['move-focus-out']      = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkDirectionType"}, name ={"notebook", "direction"}} }, 
    ['page-added']          = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['page-removed']        = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['page-reordered']      = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['reorder-tab']         = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "GtkDirectionType", "gboolean"}, name ={"notebook", "direction", "move_to_last"}} }, 
    ['select-page']         = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "gboolean"}, name ={"notebook", "move_focus"}} }, 
    ['switch-page']         = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "page", "page_num"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["enable-popup"] = {__type__="gboolean"        ,__default__ = "FALSE"       ,rwflags="rw" },
    ["group-name"]   = {__type__="gchar*"          ,__default__ = "NULL"        , __gencode__ = {"gtk_notebook_set_group_name((GtkNotebook*)({* id *}), (const char*)({* property.value *}))"} },
    page             = {__type__="gint"            ,__default__ = "-1"          ,rwflags="rw" },
    pages            = {__type__="GListModel*"                                   },
    scrollable       = {__type__="gboolean"        ,__default__ = "FALSE"       , __gencode__ = {"gtk_notebook_set_scrollable((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-border"]  = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_notebook_set_show_border((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-tabs"]    = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_notebook_set_show_tabs((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tab-pos"]      = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP" , __gencode__ = {"gtk_notebook_set_tab_pos((GtkNotebook*)({* id *}), (GtkPositionType)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkNothingAction
Gtk418.GtkNothingAction = {
  class = "GtkNothingAction", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkShortcutAction,
};

---------------------  GtkNumericSorter
Gtk418.GtkNumericSorter = {
  class = "GtkNumericSorter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_numeric_sorter_new((GtkExpression*)({* this.expression.value *}))", 
            params = { type = {"GtkExpression*"}, 
                       name = {"expression"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expression     = {__type__="GtkExpression*"                                     , __gencode__ = {"gtk_numeric_sorter_set_expression((GtkNumericSorter*)({* id *}), (GtkExpression*)({* property.value *}))"} },
    ["sort-order"] = {__type__="GtkSortType"    ,__default__ = "GTK_SORT_ASCENDING" , __gencode__ = {"gtk_numeric_sorter_set_sort_order((GtkNumericSorter*)({* id *}), (GtkSortType)({* property.value *}))"} },
  },
  parent = Gtk418.GtkSorter,
};

---------------------  GtkObjectExpression
Gtk418.GtkObjectExpression = {
  class = "GtkObjectExpression", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_object_expression_new((GObject*)({* this.object.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkExpression,
};

---------------------  GtkOverlay
Gtk418.GtkOverlay = {
  class = "GtkOverlay", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_overlay_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['get-child-position'] = {ret_type = "gboolean", params = {type = {"GtkOverlay*", "GtkWidget*", "GdkRectangle*"}, name ={"overlay", "widget", "allocation"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child = {__type__="GtkWidget*" , __gencode__ = {"gtk_overlay_set_child((GtkOverlay*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkOverlayLayout
Gtk418.GtkOverlayLayout = {
  class = "GtkOverlayLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_overlay_layout_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkLayoutManager,
};

---------------------  GtkOverlayLayoutChild
Gtk418.GtkOverlayLayoutChild = {
  class = "GtkOverlayLayoutChild", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["clip-overlay"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_overlay_layout_child_set_clip_overlay((GtkOverlayLayoutChild*)({* id *}), (gboolean)({* property.value *}))"} },
    measure          = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_overlay_layout_child_set_measure((GtkOverlayLayoutChild*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkLayoutChild,
};

---------------------  GtkPadController
Gtk418.GtkPadController = {
  class = "GtkPadController", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_pad_controller_new((GActionGroup*)({* this.group.value *}), (GdkDevice*)({* this.pad.value *}))", 
            params = { type = {"GdkDevice*"}, 
                       name = {"pad"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["action-group"] = {__type__="GActionGroup*" ,rwflags="rw" },
    pad              = {__type__="GdkDevice*"    ,rwflags="rw" },
  },
  parent = Gtk418.GtkEventController,
};

---------------------  GtkPaned
Gtk418.GtkPaned = {
  class = "GtkPaned", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_paned_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accept-position']     = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
    ['cancel-position']     = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
    ['cycle-child-focus']   = {ret_type = "gboolean", params = {type = {"GtkPaned*", "gboolean"}, name ={"paned", "reversed"}} }, 
    ['cycle-handle-focus']  = {ret_type = "gboolean", params = {type = {"GtkPaned*", "gboolean"}, name ={"paned", "reversed"}} }, 
    ['move-handle']         = {ret_type = "gboolean", params = {type = {"GtkPaned*", "GtkScrollType"}, name ={"paned", "scroll_type"}} }, 
    ['toggle-handle-focus'] = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["end-child"]          = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_paned_set_end_child((GtkPaned*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["max-position"]       = {__type__="gint"       ,__default__ = "2147483647"  },
    ["min-position"]       = {__type__="gint"       ,__default__ = "0"           },
    position               = {__type__="gint"       ,__default__ = "0"          , __gencode__ = {"gtk_paned_set_position((GtkPaned*)({* id *}), (int)({* property.value *}))"} },
    ["position-set"]       = {__type__="gboolean"   ,__default__ = "FALSE"      ,rwflags="rw" },
    ["resize-end-child"]   = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_paned_set_resize_end_child((GtkPaned*)({* id *}), (gboolean)({* property.value *}))"} },
    ["resize-start-child"] = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_paned_set_resize_start_child((GtkPaned*)({* id *}), (gboolean)({* property.value *}))"} },
    ["shrink-end-child"]   = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_paned_set_shrink_end_child((GtkPaned*)({* id *}), (gboolean)({* property.value *}))"} },
    ["shrink-start-child"] = {__type__="gboolean"   ,__default__ = "TRUE"       , __gencode__ = {"gtk_paned_set_shrink_start_child((GtkPaned*)({* id *}), (gboolean)({* property.value *}))"} },
    ["start-child"]        = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_paned_set_start_child((GtkPaned*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["wide-handle"]        = {__type__="gboolean"   ,__default__ = "FALSE"      , __gencode__ = {"gtk_paned_set_wide_handle((GtkPaned*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkPasswordEntry
Gtk418.GtkPasswordEntry = {
  class = "GtkPasswordEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_password_entry_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkPasswordEntry*"}, name ={"passwordentry"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activates-default"] = {__type__="gboolean"    ,__default__ = "FALSE" ,rwflags="rw" },
    ["extra-menu"]        = {__type__="GMenuModel*"                        , __gencode__ = {"gtk_password_entry_set_extra_menu((GtkPasswordEntry*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["placeholder-text"]  = {__type__="gchar*"      ,__default__ = "NULL"  ,rwflags="rw" },
    ["show-peek-icon"]    = {__type__="gboolean"    ,__default__ = "FALSE" , __gencode__ = {"gtk_password_entry_set_show_peek_icon((GtkPasswordEntry*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkEditable}, 
};

---------------------  GtkPasswordEntryBuffer
Gtk418.GtkPasswordEntryBuffer = {
  class = "GtkPasswordEntryBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_password_entry_buffer_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkEntryBuffer,
};

---------------------  GtkPicture
Gtk418.GtkPicture = {
  class = "GtkPicture", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_picture_new()", 
            params = { type = {}, name = {} } },
    new_for_file      = { gencode = "gtk_picture_new_for_file((GFile*)({* this.file.value *}))", 
            params = { type = {"GFile*"}, 
                       name = {"file"} } },
    new_for_filename  = { gencode = "gtk_picture_new_for_filename((const char*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_for_paintable = { gencode = "gtk_picture_new_for_paintable((GdkPaintable*)({* this.paintable.value *}))", 
            params = { type = {"GdkPaintable*"}, 
                       name = {"paintable"} } },
    new_for_pixbuf    = { gencode = "gtk_picture_new_for_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {}, name = {} } },
    new_for_resource  = { gencode = "gtk_picture_new_for_resource((const char*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["alternative-text"]  = {__type__="gchar*"        ,__default__ = "NULL"                    , __gencode__ = {"gtk_picture_set_alternative_text((GtkPicture*)({* id *}), (const char*)({* property.value *}))"} },
    ["can-shrink"]        = {__type__="gboolean"      ,__default__ = "TRUE"                    , __gencode__ = {"gtk_picture_set_can_shrink((GtkPicture*)({* id *}), (gboolean)({* property.value *}))"} },
    ["content-fit"]       = {__type__="GtkContentFit" ,__default__ = "GTK_CONTENT_FIT_CONTAIN" , __gencode__ = {"gtk_picture_set_content_fit((GtkPicture*)({* id *}), (GtkContentFit)({* property.value *}))"} },
    file                  = {__type__="GFile*"                                                 , __gencode__ = {"gtk_picture_set_file((GtkPicture*)({* id *}), (GFile*)({* property.value *}))"} },
    ["keep-aspect-ratio"] = {__type__="gboolean"      ,__default__ = "TRUE"                    , __gencode__ = {"gtk_picture_set_keep_aspect_ratio((GtkPicture*)({* id *}), (gboolean)({* property.value *}))"} },
    paintable             = {__type__="GdkPaintable*"                                          , __gencode__ = {"gtk_picture_set_paintable((GtkPicture*)({* id *}), (GdkPaintable*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkPopover
Gtk418.GtkPopover = {
  class = "GtkPopover", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_popover_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_default = {"void", {"GtkPopover*"}, {"popover"} }, 
    closed           = {"void", {"GtkPopover*"}, {"popover"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-default'] = {ret_type = "void", params = {type = {"GtkPopover*"}, name ={"popover"}} }, 
    closed               = {ret_type = "void", params = {type = {"GtkPopover*"}, name ={"popover"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    autohide              = {__type__="gboolean"        ,__default__ = "TRUE"           , __gencode__ = {"gtk_popover_set_autohide((GtkPopover*)({* id *}), (gboolean)({* property.value *}))"} },
    ["cascade-popdown"]   = {__type__="gboolean"        ,__default__ = "FALSE"          , __gencode__ = {"gtk_popover_set_cascade_popdown((GtkPopover*)({* id *}), (gboolean)({* property.value *}))"} },
    child                 = {__type__="GtkWidget*"                                      , __gencode__ = {"gtk_popover_set_child((GtkPopover*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["default-widget"]    = {__type__="GtkWidget*"                                      , __gencode__ = {"gtk_popover_set_default_widget((GtkPopover*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["has-arrow"]         = {__type__="gboolean"        ,__default__ = "TRUE"           , __gencode__ = {"gtk_popover_set_has_arrow((GtkPopover*)({* id *}), (gboolean)({* property.value *}))"} },
    ["mnemonics-visible"] = {__type__="gboolean"        ,__default__ = "FALSE"          , __gencode__ = {"gtk_popover_set_mnemonics_visible((GtkPopover*)({* id *}), (gboolean)({* property.value *}))"} },
    ["pointing-to"]       = {__type__="GdkRectangle*"                                   , __gencode__ = {"gtk_popover_set_pointing_to((GtkPopover*)({* id *}), (const GdkRectangle*)({* property.value *}))"} },
    position              = {__type__="GtkPositionType" ,__default__ = "GTK_POS_BOTTOM" , __gencode__ = {"gtk_popover_set_position((GtkPopover*)({* id *}), (GtkPositionType)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkPopoverMenuBar
Gtk418.GtkPopoverMenuBar = {
  class = "GtkPopoverMenuBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new_from_model = { gencode = "gtk_popover_menu_bar_new_from_model((GMenuModel*)({* this.model.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["menu-model"] = {__type__="GMenuModel*" , __gencode__ = {"gtk_popover_menu_bar_set_menu_model((GtkPopoverMenuBar*)({* id *}), (GMenuModel*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkProgressBar
Gtk418.GtkProgressBar = {
  class = "GtkProgressBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_progress_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ellipsize      = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE" , __gencode__ = {"gtk_progress_bar_set_ellipsize((GtkProgressBar*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    fraction       = {__type__="gdouble"            ,__default__ = "0"                    , __gencode__ = {"gtk_progress_bar_set_fraction((GtkProgressBar*)({* id *}), (double)({* property.value *}))"} },
    inverted       = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_progress_bar_set_inverted((GtkProgressBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["pulse-step"] = {__type__="gdouble"            ,__default__ = "0.1"                  , __gencode__ = {"gtk_progress_bar_set_pulse_step((GtkProgressBar*)({* id *}), (double)({* property.value *}))"} },
    ["show-text"]  = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_progress_bar_set_show_text((GtkProgressBar*)({* id *}), (gboolean)({* property.value *}))"} },
    text           = {__type__="gchar*"             ,__default__ = "NULL"                 , __gencode__ = {"gtk_progress_bar_set_text((GtkProgressBar*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkPropertyExpression
Gtk418.GtkPropertyExpression = {
  class = "GtkPropertyExpression", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_property_expression_new((GType)({* this.this_type.value *}), (GtkExpression*)({* this.expression.value *}), (const char*)({* this.property_name.value *}))", 
            params = { type = {}, name = {} } },
    new_for_pspec = { gencode = "gtk_property_expression_new_for_pspec((GtkExpression*)({* this.expression.value *}), (GParamSpec*)({* this.pspec.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkExpression,
};

---------------------  GtkRange
Gtk418.GtkRange = {
  class = "GtkRange", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    adjust_bounds    = {"void"    , {"GtkRange*", "double"}, {"range", "new_value"} }, 
    change_value     = {"gboolean", {"GtkRange*", "GtkScrollType", "double"}, {"range", "scroll", "new_value"} }, 
    get_range_border = {"void"    , {"GtkRange*", "GtkBorder*"}, {"range", "border_"} }, 
    move_slider      = {"void"    , {"GtkRange*", "GtkScrollType"}, {"range", "scroll"} }, 
    value_changed    = {"void"    , {"GtkRange*"}, {"range"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['adjust-bounds'] = {ret_type = "void"    , params = {type = {"GtkRange*", "gdouble"}, name ={"range", "value"}} }, 
    ['change-value']  = {ret_type = "gboolean", params = {type = {"GtkRange*", "GtkScrollType", "gdouble"}, name ={"range", "scroll", "value"}} }, 
    ['move-slider']   = {ret_type = "void"    , params = {type = {"GtkRange*", "GtkScrollType"}, name ={"range", "step"}} }, 
    ['value-changed'] = {ret_type = "void"    , params = {type = {"GtkRange*"}, name ={"range"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment                 = {__type__="GtkAdjustment*"                               , __gencode__ = {"gtk_range_set_adjustment((GtkRange*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["fill-level"]             = {__type__="gdouble"        ,__default__ = "1.79769e+308" , __gencode__ = {"gtk_range_set_fill_level((GtkRange*)({* id *}), (double)({* property.value *}))"} },
    inverted                   = {__type__="gboolean"       ,__default__ = "FALSE"        , __gencode__ = {"gtk_range_set_inverted((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    ["restrict-to-fill-level"] = {__type__="gboolean"       ,__default__ = "TRUE"         , __gencode__ = {"gtk_range_set_restrict_to_fill_level((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    ["round-digits"]           = {__type__="gint"           ,__default__ = "-1"           , __gencode__ = {"gtk_range_set_round_digits((GtkRange*)({* id *}), (int)({* property.value *}))"} },
    ["show-fill-level"]        = {__type__="gboolean"       ,__default__ = "FALSE"        , __gencode__ = {"gtk_range_set_show_fill_level((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkRevealer
Gtk418.GtkRevealer = {
  class = "GtkRevealer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_revealer_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child                   = {__type__="GtkWidget*"                                                                         , __gencode__ = {"gtk_revealer_set_child((GtkRevealer*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["child-revealed"]      = {__type__="gboolean"                  ,__default__ = "FALSE"                                    },
    ["reveal-child"]        = {__type__="gboolean"                  ,__default__ = "FALSE"                                   , __gencode__ = {"gtk_revealer_set_reveal_child((GtkRevealer*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["transition-duration"] = {__type__="guint"                     ,__default__ = "250"                                     , __gencode__ = {"gtk_revealer_set_transition_duration((GtkRevealer*)({* id *}), (guint)({* property.value *}))"},__construct__= 1 },
    ["transition-type"]     = {__type__="GtkRevealerTransitionType" ,__default__ = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN" , __gencode__ = {"gtk_revealer_set_transition_type((GtkRevealer*)({* id *}), (GtkRevealerTransitionType)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkScaleButton
Gtk418.GtkScaleButton = {
  class = "GtkScaleButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scale_button_new((double)({* this.min.value *}), (double)({* this.max.value *}), (double)({* this.step.value *}), (const char**)({* this.icons.value *}))", 
            params = { type = {"const char**"}, 
                       name = {"icons"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    value_changed = {"void", {"GtkScaleButton*", "double"}, {"button", "value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    popdown           = {ret_type = "void", params = {type = {"GtkScaleButton*"}, name ={"scalebutton"}} }, 
    popup             = {ret_type = "void", params = {type = {"GtkScaleButton*"}, name ={"scalebutton"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkScaleButton*", "gdouble"}, name ={"scalebutton", "value"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active        = {__type__="gboolean"       ,__default__ = "FALSE"  },
    adjustment    = {__type__="GtkAdjustment*"                        , __gencode__ = {"gtk_scale_button_set_adjustment((GtkScaleButton*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    ["has-frame"] = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_scale_button_set_has_frame((GtkScaleButton*)({* id *}), (gboolean)({* property.value *}))"} },
    icons         = {__type__="GStrv"                                 , __gencode__ = {"gtk_scale_button_set_icons((GtkScaleButton*)({* id *}), (const char**)({* property.value *}))"} },
    value         = {__type__="gdouble"        ,__default__ = "0"     , __gencode__ = {"gtk_scale_button_set_value((GtkScaleButton*)({* id *}), (double)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkScrollbar
Gtk418.GtkScrollbar = {
  class = "GtkScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scrollbar_new((GtkOrientation)({* this.orientation.value *}), (GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkOrientation", "GtkAdjustment*"}, 
                       name = {"orientation", "adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment = {__type__="GtkAdjustment*" , __gencode__ = {"gtk_scrollbar_set_adjustment((GtkScrollbar*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkScrolledWindow
Gtk418.GtkScrolledWindow = {
  class = "GtkScrolledWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scrolled_window_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['edge-overshot']  = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkPositionType"}, name ={"scrolledwindow", "pos"}} }, 
    ['edge-reached']   = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkPositionType"}, name ={"scrolledwindow", "pos"}} }, 
    ['move-focus-out'] = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkDirectionType"}, name ={"scrolledwindow", "direction_type"}} }, 
    ['scroll-child']   = {ret_type = "gboolean", params = {type = {"GtkScrolledWindow*", "GtkScrollType", "gboolean"}, name ={"scrolledwindow", "scroll", "horizontal"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child                        = {__type__="GtkWidget*"                                           , __gencode__ = {"gtk_scrolled_window_set_child((GtkScrolledWindow*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    hadjustment                  = {__type__="GtkAdjustment*"                                       , __gencode__ = {"gtk_scrolled_window_set_hadjustment((GtkScrolledWindow*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["has-frame"]                = {__type__="gboolean"       ,__default__ = "FALSE"                , __gencode__ = {"gtk_scrolled_window_set_has_frame((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hscrollbar-policy"]        = {__type__="GtkPolicyType"  ,__default__ = "GTK_POLICY_AUTOMATIC" ,rwflags="rw" },
    ["kinetic-scrolling"]        = {__type__="gboolean"       ,__default__ = "TRUE"                 , __gencode__ = {"gtk_scrolled_window_set_kinetic_scrolling((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-content-height"]       = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_max_content_height((GtkScrolledWindow*)({* id *}), (int)({* property.value *}))"} },
    ["max-content-width"]        = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_max_content_width((GtkScrolledWindow*)({* id *}), (int)({* property.value *}))"} },
    ["min-content-height"]       = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_min_content_height((GtkScrolledWindow*)({* id *}), (int)({* property.value *}))"} },
    ["min-content-width"]        = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_min_content_width((GtkScrolledWindow*)({* id *}), (int)({* property.value *}))"} },
    ["overlay-scrolling"]        = {__type__="gboolean"       ,__default__ = "TRUE"                 , __gencode__ = {"gtk_scrolled_window_set_overlay_scrolling((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["propagate-natural-height"] = {__type__="gboolean"       ,__default__ = "FALSE"                , __gencode__ = {"gtk_scrolled_window_set_propagate_natural_height((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["propagate-natural-width"]  = {__type__="gboolean"       ,__default__ = "FALSE"                , __gencode__ = {"gtk_scrolled_window_set_propagate_natural_width((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    vadjustment                  = {__type__="GtkAdjustment*"                                       , __gencode__ = {"gtk_scrolled_window_set_vadjustment((GtkScrolledWindow*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["vscrollbar-policy"]        = {__type__="GtkPolicyType"  ,__default__ = "GTK_POLICY_AUTOMATIC" ,rwflags="rw" },
    ["window-placement"]         = {__type__="GtkCornerType"  ,__default__ = "GTK_CORNER_TOP_LEFT"  ,rwflags="rw" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkSearchBar
Gtk418.GtkSearchBar = {
  class = "GtkSearchBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_search_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child                   = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_search_bar_set_child((GtkSearchBar*)({* id *}), (GtkWidget*)({* property.value *}))"},__construct__= 1 },
    ["key-capture-widget"]  = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_search_bar_set_key_capture_widget((GtkSearchBar*)({* id *}), (GtkWidget*)({* property.value *}))"},__construct__= 1 },
    ["search-mode-enabled"] = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    ["show-close-button"]   = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_search_bar_set_show_close_button((GtkSearchBar*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkSearchEntry
Gtk418.GtkSearchEntry = {
  class = "GtkSearchEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_search_entry_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate           = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['next-match']     = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['previous-match'] = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['search-changed'] = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['search-started'] = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['stop-search']    = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activates-default"] = {__type__="gboolean"        ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["input-hints"]       = {__type__="GtkInputHints"                                                , __gencode__ = {"gtk_search_entry_set_input_hints((GtkSearchEntry*)({* id *}), (GtkInputHints)({* property.value *}))"} },
    ["input-purpose"]     = {__type__="GtkInputPurpose" ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" , __gencode__ = {"gtk_search_entry_set_input_purpose((GtkSearchEntry*)({* id *}), (GtkInputPurpose)({* property.value *}))"} },
    ["placeholder-text"]  = {__type__="gchar*"          ,__default__ = "NULL"                        , __gencode__ = {"gtk_search_entry_set_placeholder_text((GtkSearchEntry*)({* id *}), (const char*)({* property.value *}))"} },
    ["search-delay"]      = {__type__="guint"           ,__default__ = "150"                         , __gencode__ = {"gtk_search_entry_set_search_delay((GtkSearchEntry*)({* id *}), (guint)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkEditable}, 
};

---------------------  GtkSeparator
Gtk418.GtkSeparator = {
  class = "GtkSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_separator_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkShortcutController
Gtk418.GtkShortcutController = {
  class = "GtkShortcutController", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_shortcut_controller_new()", 
            params = { type = {}, name = {} } },
    new_for_model = { gencode = "gtk_shortcut_controller_new_for_model((GListModel*)({* this.model.value *}))", 
            params = { type = {"GListModel*"}, 
                       name = {"model"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["item-type"]          = {__type__="GType"                                                       },
    ["mnemonic-modifiers"] = {__type__="GdkModifierType*" ,__default__ = "GDK_ALT_MASK"             ,rwflags="rw" },
    model                  = {__type__="GListModel*"                                                ,rwflags="w" },
    ["n-items"]            = {__type__="guint"            ,__default__ = "0"                         },
    scope                  = {__type__="GtkShortcutScope" ,__default__ = "GTK_SHORTCUT_SCOPE_LOCAL" , __gencode__ = {"gtk_shortcut_controller_set_scope((GtkShortcutController*)({* id *}), (GtkShortcutScope)({* property.value *}))"} },
  },
  parent = Gtk418.GtkEventController,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkShortcutLabel
Gtk418.GtkShortcutLabel = {
  class = "GtkShortcutLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_shortcut_label_new((const char*)({* this.accelerator.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"accelerator"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accelerator       = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_shortcut_label_set_accelerator((GtkShortcutLabel*)({* id *}), (const char*)({* property.value *}))"} },
    ["disabled-text"] = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_shortcut_label_set_disabled_text((GtkShortcutLabel*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkShortcutsShortcut
Gtk418.GtkShortcutsShortcut = {
  class = "GtkShortcutsShortcut", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-size-group"] = {__type__="GtkSizeGroup*"                                              ,rwflags="w" },
    accelerator          = {__type__="gchar*"           ,__default__ = "NULL"                     ,rwflags="rw" },
    ["action-name"]      = {__type__="gchar*"           ,__default__ = "NULL"                     ,rwflags="rw" },
    direction            = {__type__="GtkTextDirection" ,__default__ = "GTK_TEXT_DIR_NONE"        ,rwflags="rw" },
    icon                 = {__type__="GIcon*"                                                     ,rwflags="rw" },
    ["icon-set"]         = {__type__="gboolean"         ,__default__ = "FALSE"                    ,rwflags="rw" },
    ["shortcut-type"]    = {__type__="GtkShortcutType"  ,__default__ = "GTK_SHORTCUT_ACCELERATOR" ,rwflags="rw" },
    subtitle             = {__type__="gchar*"           ,__default__ = "\"\""                     ,rwflags="rw" },
    ["subtitle-set"]     = {__type__="gboolean"         ,__default__ = "FALSE"                    ,rwflags="rw" },
    title                = {__type__="gchar*"           ,__default__ = "\"\""                     ,rwflags="rw" },
    ["title-size-group"] = {__type__="GtkSizeGroup*"                                              ,rwflags="w" },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkSignalAction
Gtk418.GtkSignalAction = {
  class = "GtkSignalAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_signal_action_new((const char*)({* this['signal-name']value *}))", 
            params = { type = {"const char*"}, 
                       name = {"signal-name"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["signal-name"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk418.GtkShortcutAction,
};

---------------------  GtkSignalListItemFactory
Gtk418.GtkSignalListItemFactory = {
  class = "GtkSignalListItemFactory", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_signal_list_item_factory_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    bind     = {ret_type = "void", params = {type = {"GtkSignalListItemFactory*", "GObject*"}, name ={"signallistitemfactory", "object"}} }, 
    setup    = {ret_type = "void", params = {type = {"GtkSignalListItemFactory*", "GObject*"}, name ={"signallistitemfactory", "object"}} }, 
    teardown = {ret_type = "void", params = {type = {"GtkSignalListItemFactory*", "GObject*"}, name ={"signallistitemfactory", "object"}} }, 
    unbind   = {ret_type = "void", params = {type = {"GtkSignalListItemFactory*", "GObject*"}, name ={"signallistitemfactory", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkListItemFactory,
};

---------------------  GtkSpinButton
Gtk418.GtkSpinButton = {
  class = "GtkSpinButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_spin_button_new((GtkAdjustment*)({* this.adjustment.value *}), (double)({* this['climb-rate'].value *}), (guint)({* this.digits.value *}))", 
            params = { type = {"GtkAdjustment*", "double", "guint"}, 
                       name = {"adjustment", "climb-rate", "digits"} } },
    new_with_range = { gencode = "gtk_spin_button_new_with_range((double)({* this.min.value *}), (double)({* this.max.value *}), (double)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate          = {ret_type = "void"    , params = {type = {"GtkSpinButton*"}, name ={"spinbutton"}} }, 
    ['change-value']  = {ret_type = "void"    , params = {type = {"GtkSpinButton*", "GtkScrollType"}, name ={"spinbutton", "scroll"}} }, 
    input             = {ret_type = "gint"    , params = {type = {"GtkSpinButton*", "gpointer"}, name ={"spinbutton", "new_value"}} }, 
    output            = {ret_type = "gboolean", params = {type = {"GtkSpinButton*"}, name ={"spinbutton"}} }, 
    ['value-changed'] = {ret_type = "void"    , params = {type = {"GtkSpinButton*"}, name ={"spinbutton"}} }, 
    wrapped           = {ret_type = "void"    , params = {type = {"GtkSpinButton*"}, name ={"spinbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activates-default"] = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_activates_default((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    adjustment            = {__type__="GtkAdjustment*"                                               , __gencode__ = {"gtk_spin_button_set_adjustment((GtkSpinButton*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    ["climb-rate"]        = {__type__="gdouble"                   ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_climb_rate((GtkSpinButton*)({* id *}), (double)({* property.value *}))"} },
    digits                = {__type__="guint"                     ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_digits((GtkSpinButton*)({* id *}), (guint)({* property.value *}))"} },
    numeric               = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_numeric((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["snap-to-ticks"]     = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_snap_to_ticks((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["update-policy"]     = {__type__="GtkSpinButtonUpdatePolicy" ,__default__ = "GTK_UPDATE_ALWAYS" , __gencode__ = {"gtk_spin_button_set_update_policy((GtkSpinButton*)({* id *}), (GtkSpinButtonUpdatePolicy)({* property.value *}))"} },
    value                 = {__type__="gdouble"                   ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_value((GtkSpinButton*)({* id *}), (double)({* property.value *}))"} },
    wrap                  = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_wrap((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkCellEditable, Gtk418.GtkConstraintTarget, Gtk418.GtkEditable, Gtk418.GtkOrientable}, 
};

---------------------  GtkSpinner
Gtk418.GtkSpinner = {
  class = "GtkSpinner", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_spinner_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    spinning = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_spinner_set_spinning((GtkSpinner*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkStack
Gtk418.GtkStack = {
  class = "GtkStack", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_stack_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hhomogeneous            = {__type__="gboolean"               ,__default__ = "TRUE"                           , __gencode__ = {"gtk_stack_set_hhomogeneous((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    ["interpolate-size"]    = {__type__="gboolean"               ,__default__ = "FALSE"                          , __gencode__ = {"gtk_stack_set_interpolate_size((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    pages                   = {__type__="GtkSelectionModel*"                                                      },
    ["transition-duration"] = {__type__="guint"                  ,__default__ = "200"                            , __gencode__ = {"gtk_stack_set_transition_duration((GtkStack*)({* id *}), (guint)({* property.value *}))"} },
    ["transition-running"]  = {__type__="gboolean"               ,__default__ = "FALSE"                           },
    ["transition-type"]     = {__type__="GtkStackTransitionType" ,__default__ = "GTK_STACK_TRANSITION_TYPE_NONE" , __gencode__ = {"gtk_stack_set_transition_type((GtkStack*)({* id *}), (GtkStackTransitionType)({* property.value *}))"} },
    vhomogeneous            = {__type__="gboolean"               ,__default__ = "TRUE"                           , __gencode__ = {"gtk_stack_set_vhomogeneous((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-child"]       = {__type__="GtkWidget*"                                                             , __gencode__ = {"gtk_stack_set_visible_child((GtkStack*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["visible-child-name"]  = {__type__="gchar*"                 ,__default__ = "NULL"                           , __gencode__ = {"gtk_stack_set_visible_child_name((GtkStack*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkStackSidebar
Gtk418.GtkStackSidebar = {
  class = "GtkStackSidebar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_stack_sidebar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    stack = {__type__="GtkStack*" , __gencode__ = {"gtk_stack_sidebar_set_stack((GtkStackSidebar*)({* id *}), (GtkStack*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkStackSwitcher
Gtk418.GtkStackSwitcher = {
  class = "GtkStackSwitcher", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_stack_switcher_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    stack = {__type__="GtkStack*" , __gencode__ = {"gtk_stack_switcher_set_stack((GtkStackSwitcher*)({* id *}), (GtkStack*)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkStatusbar
Gtk418.GtkStatusbar = {
  class = "GtkStatusbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_statusbar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['text-popped'] = {ret_type = "void", params = {type = {"GtkStatusbar*", "guint", "gchar*"}, name ={"statusbar", "context_id", "text"}} }, 
    ['text-pushed'] = {ret_type = "void", params = {type = {"GtkStatusbar*", "guint", "gchar*"}, name ={"statusbar", "context_id", "text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkStringFilter
Gtk418.GtkStringFilter = {
  class = "GtkStringFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_string_filter_new((GtkExpression*)({* this.expression.value *}))", 
            params = { type = {"GtkExpression*"}, 
                       name = {"expression"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expression      = {__type__="GtkExpression*"                                                                   , __gencode__ = {"gtk_string_filter_set_expression((GtkStringFilter*)({* id *}), (GtkExpression*)({* property.value *}))"} },
    ["ignore-case"] = {__type__="gboolean"                 ,__default__ = "TRUE"                                   , __gencode__ = {"gtk_string_filter_set_ignore_case((GtkStringFilter*)({* id *}), (gboolean)({* property.value *}))"} },
    ["match-mode"]  = {__type__="GtkStringFilterMatchMode" ,__default__ = "GTK_STRING_FILTER_MATCH_MODE_SUBSTRING" , __gencode__ = {"gtk_string_filter_set_match_mode((GtkStringFilter*)({* id *}), (GtkStringFilterMatchMode)({* property.value *}))"} },
    search          = {__type__="gchar*"                   ,__default__ = "NULL"                                   , __gencode__ = {"gtk_string_filter_set_search((GtkStringFilter*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkFilter,
};

---------------------  GtkStringSorter
Gtk418.GtkStringSorter = {
  class = "GtkStringSorter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_string_sorter_new((GtkExpression*)({* this.expression.value *}))", 
            params = { type = {"GtkExpression*"}, 
                       name = {"expression"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    collation       = {__type__="GtkCollation"   ,__default__ = "GTK_COLLATION_UNICODE" , __gencode__ = {"gtk_string_sorter_set_collation((GtkStringSorter*)({* id *}), (GtkCollation)({* property.value *}))"} },
    expression      = {__type__="GtkExpression*"                                        , __gencode__ = {"gtk_string_sorter_set_expression((GtkStringSorter*)({* id *}), (GtkExpression*)({* property.value *}))"} },
    ["ignore-case"] = {__type__="gboolean"       ,__default__ = "TRUE"                  , __gencode__ = {"gtk_string_sorter_set_ignore_case((GtkStringSorter*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkSorter,
};

---------------------  GtkSwitch
Gtk418.GtkSwitch = {
  class = "GtkSwitch", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_switch_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate      = {ret_type = "void"    , params = {type = {"GtkSwitch*"}, name ={"switch"}} }, 
    ['state-set'] = {ret_type = "gboolean", params = {type = {"GtkSwitch*", "gboolean"}, name ={"switch", "state"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_switch_set_active((GtkSwitch*)({* id *}), (gboolean)({* property.value *}))"} },
    state  = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_switch_set_state((GtkSwitch*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkText
Gtk418.GtkText = {
  class = "GtkText", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_text_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer = { gencode = "gtk_text_new_with_buffer((GtkEntryBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkEntryBuffer*"}, 
                       name = {"buffer"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate               = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
    backspace              = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
    ['copy-clipboard']     = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
    ['cut-clipboard']      = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
    ['delete-from-cursor'] = {ret_type = "void", params = {type = {"GtkText*", "GtkDeleteType", "gint"}, name ={"text", "type", "count"}} }, 
    ['insert-at-cursor']   = {ret_type = "void", params = {type = {"GtkText*", "gchar*"}, name ={"text", "string"}} }, 
    ['insert-emoji']       = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
    ['move-cursor']        = {ret_type = "void", params = {type = {"GtkText*", "GtkMovementStep", "gint", "gboolean"}, name ={"text", "step", "count", "extend"}} }, 
    ['paste-clipboard']    = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
    ['preedit-changed']    = {ret_type = "void", params = {type = {"GtkText*", "gchar*"}, name ={"text", "preedit"}} }, 
    ['toggle-overwrite']   = {ret_type = "void", params = {type = {"GtkText*"}, name ={"text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activates-default"]       = {__type__="gboolean"        ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_set_activates_default((GtkText*)({* id *}), (gboolean)({* property.value *}))"} },
    attributes                  = {__type__="PangoAttrList*"                                               , __gencode__ = {"gtk_text_set_attributes((GtkText*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    buffer                      = {__type__="GtkEntryBuffer*"                                              , __gencode__ = {"gtk_text_set_buffer((GtkText*)({* id *}), (GtkEntryBuffer*)({* property.value *}))"},__construct__= 1 },
    ["enable-emoji-completion"] = {__type__="gboolean"        ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_set_enable_emoji_completion((GtkText*)({* id *}), (gboolean)({* property.value *}))"} },
    ["extra-menu"]              = {__type__="GMenuModel*"                                                  , __gencode__ = {"gtk_text_set_extra_menu((GtkText*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["im-module"]               = {__type__="gchar*"          ,__default__ = "NULL"                        ,rwflags="rw" },
    ["input-hints"]             = {__type__="GtkInputHints"                                                , __gencode__ = {"gtk_text_set_input_hints((GtkText*)({* id *}), (GtkInputHints)({* property.value *}))"} },
    ["input-purpose"]           = {__type__="GtkInputPurpose" ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" , __gencode__ = {"gtk_text_set_input_purpose((GtkText*)({* id *}), (GtkInputPurpose)({* property.value *}))"} },
    ["invisible-char"]          = {__type__="guint"           ,__default__ = "'*'"                         , __gencode__ = {"gtk_text_set_invisible_char((GtkText*)({* id *}), (gunichar)({* property.value *}))"} },
    ["invisible-char-set"]      = {__type__="gboolean"        ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["max-length"]              = {__type__="gint"            ,__default__ = "0"                           , __gencode__ = {"gtk_text_set_max_length((GtkText*)({* id *}), (int)({* property.value *}))"} },
    ["overwrite-mode"]          = {__type__="gboolean"        ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_set_overwrite_mode((GtkText*)({* id *}), (gboolean)({* property.value *}))"} },
    ["placeholder-text"]        = {__type__="gchar*"          ,__default__ = "NULL"                        , __gencode__ = {"gtk_text_set_placeholder_text((GtkText*)({* id *}), (const char*)({* property.value *}))"} },
    ["propagate-text-width"]    = {__type__="gboolean"        ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_set_propagate_text_width((GtkText*)({* id *}), (gboolean)({* property.value *}))"} },
    ["scroll-offset"]           = {__type__="gint"            ,__default__ = "0"                            },
    tabs                        = {__type__="PangoTabArray*"                                               , __gencode__ = {"gtk_text_set_tabs((GtkText*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    ["truncate-multiline"]      = {__type__="gboolean"        ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_set_truncate_multiline((GtkText*)({* id *}), (gboolean)({* property.value *}))"} },
    visibility                  = {__type__="gboolean"        ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_set_visibility((GtkText*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleText, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkEditable}, 
};

---------------------  GtkTextView
Gtk418.GtkTextView = {
  class = "GtkTextView", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_text_view_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer = { gencode = "gtk_text_view_new_with_buffer((GtkTextBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkTextBuffer*"}, 
                       name = {"buffer"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    backspace          = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    copy_clipboard     = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    create_buffer      = {"GtkTextBuffer*", {"GtkTextView*"}, {"text_view"} }, 
    cut_clipboard      = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    delete_from_cursor = {"void"          , {"GtkTextView*", "GtkDeleteType", "int"}, {"text_view", "type", "count"} }, 
    extend_selection   = {"gboolean"      , {"GtkTextView*", "GtkTextExtendSelection", "const GtkTextIter*", "GtkTextIter*", "GtkTextIter*"}, {"text_view", "granularity", "location", "start", "end"} }, 
    insert_at_cursor   = {"void"          , {"GtkTextView*", "const char*"}, {"text_view", "str"} }, 
    insert_emoji       = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    move_cursor        = {"void"          , {"GtkTextView*", "GtkMovementStep", "int", "gboolean"}, {"text_view", "step", "count", "extend_selection"} }, 
    paste_clipboard    = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    set_anchor         = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    snapshot_layer     = {"void"          , {"GtkTextView*", "GtkTextViewLayer", "GtkSnapshot*"}, {"text_view", "layer", "snapshot"} }, 
    toggle_overwrite   = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    backspace                 = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"text_view"}} }, 
    ['copy-clipboard']        = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['cut-clipboard']         = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['delete-from-cursor']    = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkDeleteType", "gint"}, name ={"textview", "type", "count"}} }, 
    ['extend-selection']      = {ret_type = "gboolean", params = {type = {"GtkTextView*", "GtkTextExtendSelection", "GtkTextIter*", "GtkTextIter*", "GtkTextIter*"}, name ={"textview", "granularity", "location", "start", "end"}} }, 
    ['insert-at-cursor']      = {ret_type = "void"    , params = {type = {"GtkTextView*", "gchar*"}, name ={"textview", "string"}} }, 
    ['insert-emoji']          = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['move-cursor']           = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkMovementStep", "gint", "gboolean"}, name ={"textview", "step", "count", "extend_selection"}} }, 
    ['move-viewport']         = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkScrollStep", "gint"}, name ={"textview", "step", "count"}} }, 
    ['paste-clipboard']       = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['preedit-changed']       = {ret_type = "void"    , params = {type = {"GtkTextView*", "gchar*"}, name ={"textview", "preedit"}} }, 
    ['select-all']            = {ret_type = "void"    , params = {type = {"GtkTextView*", "gboolean"}, name ={"textview", "select"}} }, 
    ['set-anchor']            = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['toggle-cursor-visible'] = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['toggle-overwrite']      = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accepts-tab"]        = {__type__="gboolean"         ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_view_set_accepts_tab((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["bottom-margin"]      = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_bottom_margin((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    buffer                 = {__type__="GtkTextBuffer*"                                                , __gencode__ = {"gtk_text_view_set_buffer((GtkTextView*)({* id *}), (GtkTextBuffer*)({* property.value *}))"} },
    ["cursor-visible"]     = {__type__="gboolean"         ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_view_set_cursor_visible((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    editable               = {__type__="gboolean"         ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_view_set_editable((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["extra-menu"]         = {__type__="GMenuModel*"                                                   , __gencode__ = {"gtk_text_view_set_extra_menu((GtkTextView*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["im-module"]          = {__type__="gchar*"           ,__default__ = "NULL"                        ,rwflags="rw" },
    indent                 = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_indent((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    ["input-hints"]        = {__type__="GtkInputHints"                                                 , __gencode__ = {"gtk_text_view_set_input_hints((GtkTextView*)({* id *}), (GtkInputHints)({* property.value *}))"} },
    ["input-purpose"]      = {__type__="GtkInputPurpose"  ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" , __gencode__ = {"gtk_text_view_set_input_purpose((GtkTextView*)({* id *}), (GtkInputPurpose)({* property.value *}))"} },
    justification          = {__type__="GtkJustification" ,__default__ = "GTK_JUSTIFY_LEFT"            , __gencode__ = {"gtk_text_view_set_justification((GtkTextView*)({* id *}), (GtkJustification)({* property.value *}))"} },
    ["left-margin"]        = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_left_margin((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    monospace              = {__type__="gboolean"         ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_view_set_monospace((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    overwrite              = {__type__="gboolean"         ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_view_set_overwrite((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["pixels-above-lines"] = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_pixels_above_lines((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    ["pixels-below-lines"] = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_pixels_below_lines((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    ["pixels-inside-wrap"] = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_pixels_inside_wrap((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    ["right-margin"]       = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_right_margin((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    tabs                   = {__type__="PangoTabArray*"                                                , __gencode__ = {"gtk_text_view_set_tabs((GtkTextView*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    ["top-margin"]         = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_top_margin((GtkTextView*)({* id *}), (int)({* property.value *}))"} },
    ["wrap-mode"]          = {__type__="GtkWrapMode"      ,__default__ = "GTK_WRAP_NONE"               , __gencode__ = {"gtk_text_view_set_wrap_mode((GtkTextView*)({* id *}), (GtkWrapMode)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleText, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkScrollable}, 
};

---------------------  GtkTreeExpander
Gtk418.GtkTreeExpander = {
  class = "GtkTreeExpander", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tree_expander_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child                = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_tree_expander_set_child((GtkTreeExpander*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["hide-expander"]    = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_tree_expander_set_hide_expander((GtkTreeExpander*)({* id *}), (gboolean)({* property.value *}))"} },
    ["indent-for-depth"] = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_tree_expander_set_indent_for_depth((GtkTreeExpander*)({* id *}), (gboolean)({* property.value *}))"} },
    ["indent-for-icon"]  = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_tree_expander_set_indent_for_icon((GtkTreeExpander*)({* id *}), (gboolean)({* property.value *}))"} },
    item                 = {__type__="GObject*"                                },
    ["list-row"]         = {__type__="GtkTreeListRow*"                        , __gencode__ = {"gtk_tree_expander_set_list_row((GtkTreeExpander*)({* id *}), (GtkTreeListRow*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkTreeListRowSorter
Gtk418.GtkTreeListRowSorter = {
  class = "GtkTreeListRowSorter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tree_list_row_sorter_new((GtkSorter*)({* this.sorter.value *}))", 
            params = { type = {"GtkSorter*"}, 
                       name = {"sorter"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    sorter = {__type__="GtkSorter*" , __gencode__ = {"gtk_tree_list_row_sorter_set_sorter((GtkTreeListRowSorter*)({* id *}), (GtkSorter*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkSorter,
};

---------------------  GtkTreeView
Gtk418.GtkTreeView = {
  class = "GtkTreeView", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_tree_view_new()", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_tree_view_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    columns_changed            = {"void"    , {"GtkTreeView*"}, {"tree_view"} }, 
    cursor_changed             = {"void"    , {"GtkTreeView*"}, {"tree_view"} }, 
    expand_collapse_cursor_row = {"gboolean", {"GtkTreeView*", "gboolean", "gboolean", "gboolean"}, {"tree_view", "logical", "expand", "open_all"} }, 
    move_cursor                = {"gboolean", {"GtkTreeView*", "GtkMovementStep", "int", "gboolean", "gboolean"}, {"tree_view", "step", "count", "extend", "modify"} }, 
    row_activated              = {"void"    , {"GtkTreeView*", "GtkTreePath*", "GtkTreeViewColumn*"}, {"tree_view", "path", "column"} }, 
    row_collapsed              = {"void"    , {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    row_expanded               = {"void"    , {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    select_all                 = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    select_cursor_parent       = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    select_cursor_row          = {"gboolean", {"GtkTreeView*", "gboolean"}, {"tree_view", "start_editing"} }, 
    start_interactive_search   = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    test_collapse_row          = {"gboolean", {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    test_expand_row            = {"gboolean", {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    toggle_cursor_row          = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    unselect_all               = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['columns-changed']            = {ret_type = "void"    , params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['cursor-changed']             = {ret_type = "void"    , params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['expand-collapse-cursor-row'] = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "gboolean", "gboolean", "gboolean"}, name ={"treeview", "object", "p0", "p1"}} }, 
    ['move-cursor']                = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkMovementStep", "gint", "gboolean", "gboolean"}, name ={"treeview", "step", "direction", "extend", "modify"}} }, 
    ['row-activated']              = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreePath*", "GtkTreeViewColumn*"}, name ={"treeview", "path", "column"}} }, 
    ['row-collapsed']              = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['row-expanded']               = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['select-all']                 = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['select-cursor-parent']       = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['select-cursor-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "gboolean"}, name ={"treeview", "object"}} }, 
    ['start-interactive-search']   = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['test-collapse-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['test-expand-row']            = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['toggle-cursor-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['unselect-all']               = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activate-on-single-click"] = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_activate_on_single_click((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["enable-grid-lines"]        = {__type__="GtkTreeViewGridLines" ,__default__ = "GTK_TREE_VIEW_GRID_LINES_NONE" ,rwflags="rw" },
    ["enable-search"]            = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_enable_search((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["enable-tree-lines"]        = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_enable_tree_lines((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["expander-column"]          = {__type__="GtkTreeViewColumn*"                                                  , __gencode__ = {"gtk_tree_view_set_expander_column((GtkTreeView*)({* id *}), (GtkTreeViewColumn*)({* property.value *}))"} },
    ["fixed-height-mode"]        = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_fixed_height_mode((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["headers-clickable"]        = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_headers_clickable((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["headers-visible"]          = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_headers_visible((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hover-expand"]             = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_hover_expand((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hover-selection"]          = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_hover_selection((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["level-indentation"]        = {__type__="gint"                 ,__default__ = "0"                             , __gencode__ = {"gtk_tree_view_set_level_indentation((GtkTreeView*)({* id *}), (int)({* property.value *}))"} },
    model                        = {__type__="GtkTreeModel*"                                                       , __gencode__ = {"gtk_tree_view_set_model((GtkTreeView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    reorderable                  = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_reorderable((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["rubber-banding"]           = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_rubber_banding((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["search-column"]            = {__type__="gint"                 ,__default__ = "-1"                            , __gencode__ = {"gtk_tree_view_set_search_column((GtkTreeView*)({* id *}), (int)({* property.value *}))"} },
    ["show-expanders"]           = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_show_expanders((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tooltip-column"]           = {__type__="gint"                 ,__default__ = "-1"                            , __gencode__ = {"gtk_tree_view_set_tooltip_column((GtkTreeView*)({* id *}), (int)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkScrollable}, 
};

---------------------  GtkVideo
Gtk418.GtkVideo = {
  class = "GtkVideo", 
  constructor = { 
    -- 名称[- ==> _], 
    new                  = { gencode = "gtk_video_new()", 
            params = { type = {}, name = {} } },
    new_for_file         = { gencode = "gtk_video_new_for_file((GFile*)({* this.file.value *}))", 
            params = { type = {"GFile*"}, 
                       name = {"file"} } },
    new_for_filename     = { gencode = "gtk_video_new_for_filename((const char*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_for_media_stream = { gencode = "gtk_video_new_for_media_stream((GtkMediaStream*)({* this.stream.value *}))", 
            params = { type = {}, name = {} } },
    new_for_resource     = { gencode = "gtk_video_new_for_resource((const char*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    autoplay             = {__type__="gboolean"                  ,__default__ = "FALSE"                         , __gencode__ = {"gtk_video_set_autoplay((GtkVideo*)({* id *}), (gboolean)({* property.value *}))"} },
    file                 = {__type__="GFile*"                                                                   , __gencode__ = {"gtk_video_set_file((GtkVideo*)({* id *}), (GFile*)({* property.value *}))"} },
    ["graphics-offload"] = {__type__="GtkGraphicsOffloadEnabled" ,__default__ = "GTK_GRAPHICS_OFFLOAD_DISABLED" , __gencode__ = {"gtk_video_set_graphics_offload((GtkVideo*)({* id *}), (GtkGraphicsOffloadEnabled)({* property.value *}))"} },
    loop                 = {__type__="gboolean"                  ,__default__ = "FALSE"                         , __gencode__ = {"gtk_video_set_loop((GtkVideo*)({* id *}), (gboolean)({* property.value *}))"} },
    ["media-stream"]     = {__type__="GtkMediaStream*"                                                          , __gencode__ = {"gtk_video_set_media_stream((GtkVideo*)({* id *}), (GtkMediaStream*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkViewport
Gtk418.GtkViewport = {
  class = "GtkViewport", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_viewport_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child               = {__type__="GtkWidget*"                       , __gencode__ = {"gtk_viewport_set_child((GtkViewport*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["scroll-to-focus"] = {__type__="gboolean"   ,__default__ = "TRUE" , __gencode__ = {"gtk_viewport_set_scroll_to_focus((GtkViewport*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkScrollable}, 
};

---------------------  GtkWindow
Gtk418.GtkWindow = {
  class = "GtkWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_default = {"void"    , {"GtkWindow*"}, {"window"} }, 
    activate_focus   = {"void"    , {"GtkWindow*"}, {"window"} }, 
    close_request    = {"gboolean", {"GtkWindow*"}, {"window"} }, 
    enable_debugging = {"gboolean", {"GtkWindow*", "gboolean"}, {"window", "toggle"} }, 
    keys_changed     = {"void"    , {"GtkWindow*"}, {"window"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-default'] = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['activate-focus']   = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['close-request']    = {ret_type = "gboolean", params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['enable-debugging'] = {ret_type = "gboolean", params = {type = {"GtkWindow*", "gboolean"}, name ={"window", "toggle"}} }, 
    ['keys-changed']     = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    application              = {__type__="GtkApplication*"                        , __gencode__ = {"gtk_window_set_application((GtkWindow*)({* id *}), (GtkApplication*)({* property.value *}))"} },
    child                    = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_window_set_child((GtkWindow*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    decorated                = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_window_set_decorated((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["default-height"]       = {__type__="gint"            ,__default__ = "0"     ,rwflags="rw" },
    ["default-widget"]       = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_window_set_default_widget((GtkWindow*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["default-width"]        = {__type__="gint"            ,__default__ = "0"     ,rwflags="rw" },
    deletable                = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_window_set_deletable((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["destroy-with-parent"]  = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_window_set_destroy_with_parent((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    display                  = {__type__="GdkDisplay*"                            , __gencode__ = {"gtk_window_set_display((GtkWindow*)({* id *}), (GdkDisplay*)({* property.value *}))"} },
    ["focus-visible"]        = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_window_set_focus_visible((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["focus-widget"]         = {__type__="GtkWidget*"                             ,rwflags="rw" },
    fullscreened             = {__type__="gboolean"        ,__default__ = "FALSE" ,rwflags="rw" },
    ["handle-menubar-accel"] = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_window_set_handle_menubar_accel((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hide-on-close"]        = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_window_set_hide_on_close((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["icon-name"]            = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_window_set_icon_name((GtkWindow*)({* id *}), (const char*)({* property.value *}))"} },
    ["is-active"]            = {__type__="gboolean"        ,__default__ = "FALSE"  },
    maximized                = {__type__="gboolean"        ,__default__ = "FALSE" ,rwflags="rw" },
    ["mnemonics-visible"]    = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_window_set_mnemonics_visible((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    modal                    = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_window_set_modal((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    resizable                = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_window_set_resizable((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["startup-id"]           = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_window_set_startup_id((GtkWindow*)({* id *}), (const char*)({* property.value *}))"} },
    suspended                = {__type__="gboolean"        ,__default__ = "FALSE"  },
    title                    = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_window_set_title((GtkWindow*)({* id *}), (const char*)({* property.value *}))"} },
    titlebar                 = {__type__="GtkWidget*"                             , __gencode__ = {"gtk_window_set_titlebar((GtkWindow*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["transient-for"]        = {__type__="GtkWindow*"                             , __gencode__ = {"gtk_window_set_transient_for((GtkWindow*)({* id *}), (GtkWindow*)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkWindowControls
Gtk418.GtkWindowControls = {
  class = "GtkWindowControls", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_controls_new((GtkPackType)({* this.side.value *}))", 
            params = { type = {"GtkPackType"}, 
                       name = {"side"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["decoration-layout"]   = {__type__="gchar*"      ,__default__ = "NULL"           , __gencode__ = {"gtk_window_controls_set_decoration_layout((GtkWindowControls*)({* id *}), (const char*)({* property.value *}))"} },
    empty                   = {__type__="gboolean"    ,__default__ = "TRUE"            },
    side                    = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" , __gencode__ = {"gtk_window_controls_set_side((GtkWindowControls*)({* id *}), (GtkPackType)({* property.value *}))"} },
    ["use-native-controls"] = {__type__="gboolean"    ,__default__ = "FALSE"          , __gencode__ = {"gtk_window_controls_set_use_native_controls((GtkWindowControls*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkWindowHandle
Gtk418.GtkWindowHandle = {
  class = "GtkWindowHandle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_handle_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    child = {__type__="GtkWidget*" , __gencode__ = {"gtk_window_handle_set_child((GtkWindowHandle*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWidget,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkAboutDialog
Gtk418.GtkAboutDialog = {
  class = "GtkAboutDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_about_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-link'] = {ret_type = "gboolean", params = {type = {"GtkAboutDialog*", "gchar*"}, name ={"aboutdialog", "uri"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    artists                = {__type__="GStrv"                                              , __gencode__ = {"gtk_about_dialog_set_artists((GtkAboutDialog*)({* id *}), (const char**)({* property.value *}))"} },
    authors                = {__type__="GStrv"                                              , __gencode__ = {"gtk_about_dialog_set_authors((GtkAboutDialog*)({* id *}), (const char**)({* property.value *}))"} },
    comments               = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_comments((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    copyright              = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_copyright((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    documenters            = {__type__="GStrv"                                              , __gencode__ = {"gtk_about_dialog_set_documenters((GtkAboutDialog*)({* id *}), (const char**)({* property.value *}))"} },
    license                = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_license((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["license-type"]       = {__type__="GtkLicense"    ,__default__ = "GTK_LICENSE_UNKNOWN" , __gencode__ = {"gtk_about_dialog_set_license_type((GtkAboutDialog*)({* id *}), (GtkLicense)({* property.value *}))"} },
    logo                   = {__type__="GdkPaintable*"                                      , __gencode__ = {"gtk_about_dialog_set_logo((GtkAboutDialog*)({* id *}), (GdkPaintable*)({* property.value *}))"} },
    ["logo-icon-name"]     = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_logo_icon_name((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["program-name"]       = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_program_name((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["system-information"] = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_system_information((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["translator-credits"] = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_translator_credits((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    version                = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_version((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    website                = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_website((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["website-label"]      = {__type__="gchar*"        ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_website_label((GtkAboutDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["wrap-license"]       = {__type__="gboolean"      ,__default__ = "FALSE"               , __gencode__ = {"gtk_about_dialog_set_wrap_license((GtkAboutDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkWindow,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkAnyFilter
Gtk418.GtkAnyFilter = {
  class = "GtkAnyFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_any_filter_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkMultiFilter,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkApplicationWindow
Gtk418.GtkApplicationWindow = {
  class = "GtkApplicationWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_application_window_new((GtkApplication*)({* this.application.value *}))", 
            params = { type = {"GtkApplication*"}, 
                       name = {"application"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-menubar"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_application_window_set_show_menubar((GtkApplicationWindow*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkWindow,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkAssistant
Gtk418.GtkAssistant = {
  class = "GtkAssistant", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_assistant_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    apply   = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    cancel  = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    close   = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    escape  = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    prepare = {ret_type = "void", params = {type = {"GtkAssistant*", "GtkWidget*"}, name ={"assistant", "page"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    pages              = {__type__="GListModel*"                      },
    ["use-header-bar"] = {__type__="gint"        ,__default__ = "-1" ,rwflags="rw" },
  },
  parent = Gtk418.GtkWindow,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkCellRendererAccel
Gtk418.GtkCellRendererAccel = {
  class = "GtkCellRendererAccel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_accel_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-cleared'] = {ret_type = "void", params = {type = {"GtkCellRendererAccel*", "gchar*"}, name ={"cellrendereraccel", "path_string"}} }, 
    ['accel-edited']  = {ret_type = "void", params = {type = {"GtkCellRendererAccel*", "gchar*", "guint", "GdkModifierType*", "guint"}, name ={"cellrendereraccel", "path_string", "accel_key", "accel_mods", "hardware_keycode"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-key"]  = {__type__="guint"                    ,__default__ = "0"                                ,rwflags="rw" },
    ["accel-mode"] = {__type__="GtkCellRendererAccelMode" ,__default__ = "GTK_CELL_RENDERER_ACCEL_MODE_GTK" ,rwflags="rw" },
    ["accel-mods"] = {__type__="GdkModifierType*"                                                           ,rwflags="rw" },
    keycode        = {__type__="guint"                    ,__default__ = "0"                                ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRendererText,
};

---------------------  GtkCellRendererCombo
Gtk418.GtkCellRendererCombo = {
  class = "GtkCellRendererCombo", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_combo_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkCellRendererCombo*", "gchar*", "GtkTreeIter*"}, name ={"cellrenderercombo", "path_string", "new_iter"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["has-entry"]   = {__type__="gboolean"      ,__default__ = "TRUE" ,rwflags="rw" },
    model           = {__type__="GtkTreeModel*"                       ,rwflags="rw" },
    ["text-column"] = {__type__="gint"          ,__default__ = "-1"   ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRendererText,
};

---------------------  GtkCellRendererSpin
Gtk418.GtkCellRendererSpin = {
  class = "GtkCellRendererSpin", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_spin_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment     = {__type__="GtkAdjustment*"                    ,rwflags="rw" },
    ["climb-rate"] = {__type__="gdouble"        ,__default__ = "0" ,rwflags="rw" },
    digits         = {__type__="guint"          ,__default__ = "0" ,rwflags="rw" },
  },
  parent = Gtk418.GtkCellRendererText,
};

---------------------  GtkComboBoxText
Gtk418.GtkComboBoxText = {
  class = "GtkComboBoxText", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_combo_box_text_new()", 
            params = { type = {}, name = {} } },
    new_with_entry = { gencode = "gtk_combo_box_text_new_with_entry()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkComboBox,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkCellEditable, Gtk418.GtkCellLayout, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkDialog
Gtk418.GtkDialog = {
  class = "GtkDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_dialog_new()", 
            params = { type = {}, name = {} } },
    new_with_buttons = { gencode = "gtk_dialog_new_with_buttons((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (const char*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const char*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close    = {"void", {"GtkDialog*"}, {"dialog"} }, 
    response = {"void", {"GtkDialog*", "int"}, {"dialog", "response_id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close    = {ret_type = "void", params = {type = {"GtkDialog*"}, name ={"dialog"}} }, 
    response = {ret_type = "void", params = {type = {"GtkDialog*", "int"}, name ={"dialog", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["use-header-bar"] = {__type__="gint" ,__default__ = "-1" ,rwflags="rw" },
  },
  parent = Gtk418.GtkWindow,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkEmojiChooser
Gtk418.GtkEmojiChooser = {
  class = "GtkEmojiChooser", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_emoji_chooser_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['emoji-picked'] = {ret_type = "void", params = {type = {"GtkEmojiChooser*", "gchar*"}, name ={"emojichooser", "text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkPopover,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkEveryFilter
Gtk418.GtkEveryFilter = {
  class = "GtkEveryFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_every_filter_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkMultiFilter,
  implement = {Gtk418.GtkBuildable}, 
};

---------------------  GtkGestureRotate
Gtk418.GtkGestureRotate = {
  class = "GtkGestureRotate", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_rotate_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['angle-changed'] = {ret_type = "void", params = {type = {"GtkGestureRotate*", "gdouble", "gdouble"}, name ={"gesturerotate", "angle", "angle_delta"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkGesture,
};

---------------------  GtkGestureSingle
Gtk418.GtkGestureSingle = {
  class = "GtkGestureSingle", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    button         = {__type__="guint"    ,__default__ = "1"     , __gencode__ = {"gtk_gesture_single_set_button((GtkGestureSingle*)({* id *}), (guint)({* property.value *}))"} },
    exclusive      = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_gesture_single_set_exclusive((GtkGestureSingle*)({* id *}), (gboolean)({* property.value *}))"} },
    ["touch-only"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_gesture_single_set_touch_only((GtkGestureSingle*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkGesture,
};

---------------------  GtkGestureZoom
Gtk418.GtkGestureZoom = {
  class = "GtkGestureZoom", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_zoom_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['scale-changed'] = {ret_type = "void", params = {type = {"GtkGestureZoom*", "gdouble"}, name ={"gesturezoom", "scale"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkGesture,
};

---------------------  GtkGridView
Gtk418.GtkGridView = {
  class = "GtkGridView", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_grid_view_new((GtkSelectionModel*)({* this.model.value *}), (GtkListItemFactory*)({* this.factory.value *}))", 
            params = { type = {"GtkSelectionModel*", "GtkListItemFactory*"}, 
                       name = {"model", "factory"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkGridView*", "guint"}, name ={"gridview", "position"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["enable-rubberband"]     = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_grid_view_set_enable_rubberband((GtkGridView*)({* id *}), (gboolean)({* property.value *}))"} },
    factory                   = {__type__="GtkListItemFactory*"                                   , __gencode__ = {"gtk_grid_view_set_factory((GtkGridView*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    ["max-columns"]           = {__type__="guint"               ,__default__ = "7"                , __gencode__ = {"gtk_grid_view_set_max_columns((GtkGridView*)({* id *}), (guint)({* property.value *}))"} },
    ["min-columns"]           = {__type__="guint"               ,__default__ = "1"                , __gencode__ = {"gtk_grid_view_set_min_columns((GtkGridView*)({* id *}), (guint)({* property.value *}))"} },
    model                     = {__type__="GtkSelectionModel*"                                    , __gencode__ = {"gtk_grid_view_set_model((GtkGridView*)({* id *}), (GtkSelectionModel*)({* property.value *}))"} },
    ["single-click-activate"] = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_grid_view_set_single_click_activate((GtkGridView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tab-behavior"]          = {__type__="GtkListTabBehavior"  ,__default__ = "GTK_LIST_TAB_ALL" , __gencode__ = {"gtk_grid_view_set_tab_behavior((GtkGridView*)({* id *}), (GtkListTabBehavior)({* property.value *}))"} },
  },
  parent = Gtk418.GtkListBase,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable, Gtk418.GtkScrollable}, 
};

---------------------  GtkLinkButton
Gtk418.GtkLinkButton = {
  class = "GtkLinkButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_link_button_new((const char*)({* this.uri.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"uri"} } },
    new_with_label = { gencode = "gtk_link_button_new_with_label((const char*)({* this.uri.value *}), (const char*)({* this.label.value *}))", 
            params = { type = {"const char*", "const char*"}, 
                       name = {"uri", "label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-link'] = {ret_type = "gboolean", params = {type = {"GtkLinkButton*"}, name ={"linkbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    uri     = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_link_button_set_uri((GtkLinkButton*)({* id *}), (const char*)({* property.value *}))"} },
    visited = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_link_button_set_visited((GtkLinkButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkButton,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkListView
Gtk418.GtkListView = {
  class = "GtkListView", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_list_view_new((GtkSelectionModel*)({* this.model.value *}), (GtkListItemFactory*)({* this.factory.value *}))", 
            params = { type = {"GtkSelectionModel*", "GtkListItemFactory*"}, 
                       name = {"model", "factory"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkListView*", "guint"}, name ={"listview", "position"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["enable-rubberband"]     = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_list_view_set_enable_rubberband((GtkListView*)({* id *}), (gboolean)({* property.value *}))"} },
    factory                   = {__type__="GtkListItemFactory*"                                   , __gencode__ = {"gtk_list_view_set_factory((GtkListView*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    ["header-factory"]        = {__type__="GtkListItemFactory*"                                   , __gencode__ = {"gtk_list_view_set_header_factory((GtkListView*)({* id *}), (GtkListItemFactory*)({* property.value *}))"} },
    model                     = {__type__="GtkSelectionModel*"                                    , __gencode__ = {"gtk_list_view_set_model((GtkListView*)({* id *}), (GtkSelectionModel*)({* property.value *}))"} },
    ["show-separators"]       = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_list_view_set_show_separators((GtkListView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["single-click-activate"] = {__type__="gboolean"            ,__default__ = "FALSE"            , __gencode__ = {"gtk_list_view_set_single_click_activate((GtkListView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tab-behavior"]          = {__type__="GtkListTabBehavior"  ,__default__ = "GTK_LIST_TAB_ALL" , __gencode__ = {"gtk_list_view_set_tab_behavior((GtkListView*)({* id *}), (GtkListTabBehavior)({* property.value *}))"} },
  },
  parent = Gtk418.GtkListBase,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable, Gtk418.GtkScrollable}, 
};

---------------------  GtkLockButton
Gtk418.GtkLockButton = {
  class = "GtkLockButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_lock_button_new((GPermission*)({* this.permission.value *}))", 
            params = { type = {"GPermission*"}, 
                       name = {"permission"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    permission                 = {__type__="GPermission*"                                                                                         , __gencode__ = {"gtk_lock_button_set_permission((GtkLockButton*)({* id *}), (GPermission*)({* property.value *}))"} },
    ["text-lock"]              = {__type__="gchar*"       ,__default__ = "\"Lock\""                                                               ,rwflags="rw",__construct__= 1 },
    ["text-unlock"]            = {__type__="gchar*"       ,__default__ = "\"Unlock\""                                                             ,rwflags="rw",__construct__= 1 },
    ["tooltip-lock"]           = {__type__="gchar*"       ,__default__ = "\"Dialog is unlocked.\nClick to prevent further changes\""              ,rwflags="rw",__construct__= 1 },
    ["tooltip-not-authorized"] = {__type__="gchar*"       ,__default__ = "\"System policy prevents changes.\nContact your system administrator\"" ,rwflags="rw",__construct__= 1 },
    ["tooltip-unlock"]         = {__type__="gchar*"       ,__default__ = "\"Dialog is locked.\nClick to make changes\""                           ,rwflags="rw",__construct__= 1 },
  },
  parent = Gtk418.GtkButton,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkPopoverMenu
Gtk418.GtkPopoverMenu = {
  class = "GtkPopoverMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new_from_model      = { gencode = "gtk_popover_menu_new_from_model((GMenuModel*)({* this.model.value *}))", 
            params = { type = {}, name = {} } },
    new_from_model_full = { gencode = "gtk_popover_menu_new_from_model_full((GMenuModel*)({* this.model.value *}), (GtkPopoverMenuFlags)({* this.flags.value *}))", 
            params = { type = {"GtkPopoverMenuFlags"}, 
                       name = {"flags"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    flags               = {__type__="GtkPopoverMenuFlags"                       , __gencode__ = {"gtk_popover_menu_set_flags((GtkPopoverMenu*)({* id *}), (GtkPopoverMenuFlags)({* property.value *}))"} },
    ["menu-model"]      = {__type__="GMenuModel*"                               , __gencode__ = {"gtk_popover_menu_set_menu_model((GtkPopoverMenu*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["visible-submenu"] = {__type__="gchar*"              ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk418.GtkPopover,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkScale
Gtk418.GtkScale = {
  class = "GtkScale", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_scale_new((GtkOrientation)({* this.orientation.value *}), (GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkOrientation", "GtkAdjustment*"}, 
                       name = {"orientation", "adjustment"} } },
    new_with_range = { gencode = "gtk_scale_new_with_range((GtkOrientation)({* this.orientation.value *}), (double)({* this.min.value *}), (double)({* this.max.value *}), (double)({* this.step.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_layout_offsets = {"void", {"GtkScale*", "int*", "int*"}, {"scale", "x", "y"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    digits         = {__type__="gint"            ,__default__ = "1"           , __gencode__ = {"gtk_scale_set_digits((GtkScale*)({* id *}), (int)({* property.value *}))"} },
    ["draw-value"] = {__type__="gboolean"        ,__default__ = "FALSE"       , __gencode__ = {"gtk_scale_set_draw_value((GtkScale*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-origin"] = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_scale_set_has_origin((GtkScale*)({* id *}), (gboolean)({* property.value *}))"} },
    ["value-pos"]  = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP" , __gencode__ = {"gtk_scale_set_value_pos((GtkScale*)({* id *}), (GtkPositionType)({* property.value *}))"} },
  },
  parent = Gtk418.GtkRange,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkShortcutsGroup
Gtk418.GtkShortcutsGroup = {
  class = "GtkShortcutsGroup", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-size-group"] = {__type__="GtkSizeGroup*"                       ,rwflags="w" },
    height               = {__type__="guint"         ,__default__ = "1"     },
    title                = {__type__="gchar*"        ,__default__ = "\"\"" ,rwflags="rw" },
    ["title-size-group"] = {__type__="GtkSizeGroup*"                       ,rwflags="w" },
    view                 = {__type__="gchar*"        ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk418.GtkBox,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkShortcutsSection
Gtk418.GtkShortcutsSection = {
  class = "GtkShortcutsSection", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-current-page'] = {ret_type = "gboolean", params = {type = {"GtkShortcutsSection*", "gint"}, name ={"shortcutssection", "offset"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["max-height"]   = {__type__="guint"  ,__default__ = "15"   ,rwflags="rw" },
    ["section-name"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    title            = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    ["view-name"]    = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk418.GtkBox,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkShortcutsWindow
Gtk418.GtkShortcutsWindow = {
  class = "GtkShortcutsWindow", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close  = {ret_type = "void", params = {type = {"GtkShortcutsWindow*"}, name ={"shortcutswindow"}} }, 
    search = {ret_type = "void", params = {type = {"GtkShortcutsWindow*"}, name ={"shortcutswindow"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["section-name"] = {__type__="gchar*" ,__default__ = "\"internal-search\"" ,rwflags="rw" },
    ["view-name"]    = {__type__="gchar*" ,__default__ = "NULL"                ,rwflags="rw" },
  },
  parent = Gtk418.GtkWindow,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkToggleButton
Gtk418.GtkToggleButton = {
  class = "GtkToggleButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_toggle_button_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_toggle_button_new_with_label((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_toggle_button_new_with_mnemonic((const char*)({* this.label.value *}))", 
            params = { type = {"const char*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleButton*"}, {"toggle_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleButton*"}, name ={"toggle_button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean"         ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_button_set_active((GtkToggleButton*)({* id *}), (gboolean)({* property.value *}))"} },
    group  = {__type__="GtkToggleButton*"                        , __gencode__ = {"gtk_toggle_button_set_group((GtkToggleButton*)({* id *}), (GtkToggleButton*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkButton,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkActionable, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget}, 
};

---------------------  GtkVolumeButton
Gtk418.GtkVolumeButton = {
  class = "GtkVolumeButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_volume_button_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["use-symbolic"] = {__type__="gboolean" ,__default__ = "TRUE" ,rwflags="rw",__construct__= 1 },
  },
  parent = Gtk418.GtkScaleButton,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAccessibleRange, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkOrientable}, 
};

---------------------  GtkAppChooserDialog
Gtk418.GtkAppChooserDialog = {
  class = "GtkAppChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new                  = { gencode = "gtk_app_chooser_dialog_new((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GFile*)({* this.file.value *}))", 
            params = { type = {"GtkWindow*"}, 
                       name = {"parent"} } },
    new_for_content_type = { gencode = "gtk_app_chooser_dialog_new_for_content_type((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (const char*)({* this['content-type'].value *}))", 
            params = { type = {"GtkWindow*", "const char*"}, 
                       name = {"parent", "content-type"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    gfile   = {__type__="GFile*"                       ,rwflags="rw" },
    heading = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_app_chooser_dialog_set_heading((GtkAppChooserDialog*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkAppChooser, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkColorChooserDialog
Gtk418.GtkColorChooserDialog = {
  class = "GtkColorChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_chooser_dialog_new((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const char*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-editor"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkColorChooser, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkDragSource
Gtk418.GtkDragSource = {
  class = "GtkDragSource", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drag_source_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['drag-begin']  = {ret_type = "void"                 , params = {type = {"GtkDragSource*", "{Gdk.Drag}"}, name ={"dragsource", "drag"}} }, 
    ['drag-cancel'] = {ret_type = "gboolean"             , params = {type = {"GtkDragSource*", "{Gdk.Drag}", "{Gdk.DragCancelReason}"}, name ={"dragsource", "drag", "reason"}} }, 
    ['drag-end']    = {ret_type = "void"                 , params = {type = {"GtkDragSource*", "{Gdk.Drag}", "gboolean"}, name ={"dragsource", "drag", "delete_data"}} }, 
    prepare         = {ret_type = "{Gdk.ContentProvider}", params = {type = {"GtkDragSource*", "gdouble", "gdouble"}, name ={"dragsource", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    actions = {__type__="GdkDragAction"       ,__default__ = "GDK_ACTION_COPY" , __gencode__ = {"gtk_drag_source_set_actions((GtkDragSource*)({* id *}), (GdkDragAction)({* property.value *}))"} },
    content = {__type__="GdkContentProvider*"                                  , __gencode__ = {"gtk_drag_source_set_content((GtkDragSource*)({* id *}), (GdkContentProvider*)({* property.value *}))"} },
  },
  parent = Gtk418.GtkGestureSingle,
};

---------------------  GtkFileChooserDialog
Gtk418.GtkFileChooserDialog = {
  class = "GtkFileChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_chooser_dialog_new((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const char*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const char*", "GtkWindow*", "GtkFileChooserAction"}, 
                       name = {"title", "parent", "action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkFileChooser, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkFontChooserDialog
Gtk418.GtkFontChooserDialog = {
  class = "GtkFontChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_chooser_dialog_new((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const char*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkFontChooser, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkGestureClick
Gtk418.GtkGestureClick = {
  class = "GtkGestureClick", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_click_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    pressed              = {ret_type = "void", params = {type = {"GtkGestureClick*", "gint", "gdouble", "gdouble"}, name ={"gestureclick", "n_press", "x", "y"}} }, 
    released             = {ret_type = "void", params = {type = {"GtkGestureClick*", "gint", "gdouble", "gdouble"}, name ={"gestureclick", "n_press", "x", "y"}} }, 
    stopped              = {ret_type = "void", params = {type = {"GtkGestureClick*"}, name ={"gestureclick"}} }, 
    ['unpaired-release'] = {ret_type = "void", params = {type = {"GtkGestureClick*", "gdouble", "gdouble", "guint", "GdkEventSequence*"}, name ={"gestureclick", "x", "y", "button", "sequence"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkGestureSingle,
};

---------------------  GtkGestureDrag
Gtk418.GtkGestureDrag = {
  class = "GtkGestureDrag", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_drag_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['drag-begin']  = {ret_type = "void", params = {type = {"GtkGestureDrag*", "gdouble", "gdouble"}, name ={"gesturedrag", "start_x", "start_y"}} }, 
    ['drag-end']    = {ret_type = "void", params = {type = {"GtkGestureDrag*", "gdouble", "gdouble"}, name ={"gesturedrag", "offset_x", "offset_y"}} }, 
    ['drag-update'] = {ret_type = "void", params = {type = {"GtkGestureDrag*", "gdouble", "gdouble"}, name ={"gesturedrag", "offset_x", "offset_y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkGestureSingle,
};

---------------------  GtkGestureLongPress
Gtk418.GtkGestureLongPress = {
  class = "GtkGestureLongPress", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_long_press_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    cancelled = {ret_type = "void", params = {type = {"GtkGestureLongPress*"}, name ={"gesturelongpress"}} }, 
    pressed   = {ret_type = "void", params = {type = {"GtkGestureLongPress*", "gdouble", "gdouble"}, name ={"gesturelongpress", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["delay-factor"] = {__type__="gdouble" ,__default__ = "1" , __gencode__ = {"gtk_gesture_long_press_set_delay_factor((GtkGestureLongPress*)({* id *}), (double)({* property.value *}))"} },
  },
  parent = Gtk418.GtkGestureSingle,
};

---------------------  GtkGestureStylus
Gtk418.GtkGestureStylus = {
  class = "GtkGestureStylus", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_stylus_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    down      = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "x", "y"}} }, 
    motion    = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "x", "y"}} }, 
    proximity = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "x", "y"}} }, 
    up        = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["stylus-only"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_gesture_stylus_set_stylus_only((GtkGestureStylus*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk418.GtkGestureSingle,
};

---------------------  GtkGestureSwipe
Gtk418.GtkGestureSwipe = {
  class = "GtkGestureSwipe", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_swipe_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    swipe = {ret_type = "void", params = {type = {"GtkGestureSwipe*", "gdouble", "gdouble"}, name ={"gestureswipe", "velocity_x", "velocity_y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkGestureSingle,
};

---------------------  GtkMessageDialog
Gtk418.GtkMessageDialog = {
  class = "GtkMessageDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_message_dialog_new((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GtkMessageType)({* this.type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const char*)({* this.message_format.value *}), 0)", 
            params = { type = {"GtkWindow*", "GtkButtonsType"}, 
                       name = {"parent", "buttons"} } },
    new_with_markup = { gencode = "gtk_message_dialog_new_with_markup((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GtkMessageType)({* this.type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const char*)({* this.message_format.value *}), 0)", 
            params = { type = {"GtkWindow*", "GtkButtonsType"}, 
                       name = {"parent", "buttons"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    buttons                  = {__type__="GtkButtonsType" ,__default__ = "GTK_BUTTONS_NONE" ,rwflags="w" },
    ["message-area"]         = {__type__="GtkWidget*"                                        },
    ["message-type"]         = {__type__="GtkMessageType" ,__default__ = "GTK_MESSAGE_INFO" ,rwflags="rw",__construct__= 1 },
    ["secondary-text"]       = {__type__="gchar*"         ,__default__ = "NULL"             ,rwflags="rw" },
    ["secondary-use-markup"] = {__type__="gboolean"       ,__default__ = "FALSE"            ,rwflags="rw" },
    text                     = {__type__="gchar*"         ,__default__ = "\"\""             ,rwflags="rw" },
    ["use-markup"]           = {__type__="gboolean"       ,__default__ = "FALSE"            ,rwflags="rw" },
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkPageSetupUnixDialog
Gtk418.GtkPageSetupUnixDialog = {
  class = "GtkPageSetupUnixDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_page_setup_unix_dialog_new((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const char*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkPrintUnixDialog
Gtk418.GtkPrintUnixDialog = {
  class = "GtkPrintUnixDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_unix_dialog_new((const char*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const char*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["current-page"]        = {__type__="gint"                 ,__default__ = "-1"    , __gencode__ = {"gtk_print_unix_dialog_set_current_page((GtkPrintUnixDialog*)({* id *}), (int)({* property.value *}))"} },
    ["embed-page-setup"]    = {__type__="gboolean"             ,__default__ = "FALSE" , __gencode__ = {"gtk_print_unix_dialog_set_embed_page_setup((GtkPrintUnixDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-selection"]       = {__type__="gboolean"             ,__default__ = "FALSE" , __gencode__ = {"gtk_print_unix_dialog_set_has_selection((GtkPrintUnixDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    ["manual-capabilities"] = {__type__="GtkPrintCapabilities"                        , __gencode__ = {"gtk_print_unix_dialog_set_manual_capabilities((GtkPrintUnixDialog*)({* id *}), (GtkPrintCapabilities)({* property.value *}))"} },
    ["page-setup"]          = {__type__="GtkPageSetup*"                               , __gencode__ = {"gtk_print_unix_dialog_set_page_setup((GtkPrintUnixDialog*)({* id *}), (GtkPageSetup*)({* property.value *}))"} },
    ["print-settings"]      = {__type__="GtkPrintSettings*"                           ,rwflags="rw" },
    ["selected-printer"]    = {__type__="GtkPrinter*"                                  },
    ["support-selection"]   = {__type__="gboolean"             ,__default__ = "FALSE" , __gencode__ = {"gtk_print_unix_dialog_set_support_selection((GtkPrintUnixDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk418.GtkDialog,
  implement = {Gtk418.GtkAccessible, Gtk418.GtkBuildable, Gtk418.GtkConstraintTarget, Gtk418.GtkNative, Gtk418.GtkRoot, Gtk418.GtkShortcutManager}, 
};

---------------------  GtkGesturePan
Gtk418.GtkGesturePan = {
  class = "GtkGesturePan", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_pan_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    pan = {ret_type = "void", params = {type = {"GtkGesturePan*", "GtkPanDirection", "gdouble"}, name ={"gesturepan", "direction", "offset"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL" , __gencode__ = {"gtk_gesture_pan_set_orientation((GtkGesturePan*)({* id *}), (GtkOrientation)({* property.value *}))"} },
  },
  parent = Gtk418.GtkGestureDrag,
};

----  [Gtk Classes] End ... 
----  [Gtk Enumerates] Start ... 
Gtk418.GtkEnumerationes = Gtk418.GtkEnumerationes or {}
do
    local merge_list = function (old_list)
        if Gtk418.GtkEnumerationes == nil then
            return old_list
        end
        for i, v in pairs(Gtk418.GtkEnumerationes) do
            old_list[i] = v
        end
        return old_list
    end
    Gtk418.GtkEnumerationes = merge_list({
        GtkAccessibleAnnouncementPriority = {
        { macro = 'GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH'  , name = "high",   nick = "high",   value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW'   , name = "low",    nick = "low",    value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM', name = "medium", nick = "medium", value = "1"}, 
    },
    GtkAccessibleAutocomplete = {
        { macro = 'GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH'  , name = "both",   nick = "both",   value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE', name = "inline", nick = "inline", value = "1"}, 
        { macro = 'GTK_ACCESSIBLE_AUTOCOMPLETE_LIST'  , name = "list",   nick = "list",   value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_AUTOCOMPLETE_NONE'  , name = "none",   nick = "none",   value = "0"}, 
    },
    GtkAccessibleInvalidState = {
        { macro = 'GTK_ACCESSIBLE_INVALID_FALSE'   , name = "false",    nick = "false",    value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_INVALID_GRAMMAR' , name = "grammar",  nick = "grammar",  value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_INVALID_SPELLING', name = "spelling", nick = "spelling", value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_INVALID_TRUE'    , name = "true",     nick = "true",     value = "1"}, 
    },
    GtkAccessiblePlatformState = {
        { macro = 'GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE'   , name = "active",    nick = "active",    value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE', name = "focusable", nick = "focusable", value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED'  , name = "focused",   nick = "focused",   value = "1"}, 
    },
    GtkAccessibleProperty = {
        { macro = 'GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE'    , name = "autocomplete",     nick = "autocomplete",     value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_DESCRIPTION'     , name = "description",      nick = "description",      value = "1"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_HAS_POPUP'       , name = "has_popup",        nick = "has-popup",        value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_HELP_TEXT'       , name = "help_text",        nick = "help-text",        value = "19"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS'   , name = "key_shortcuts",    nick = "key-shortcuts",    value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_LABEL'           , name = "label",            nick = "label",            value = "4"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_LEVEL'           , name = "level",            nick = "level",            value = "5"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_MODAL'           , name = "modal",            nick = "modal",            value = "6"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_MULTI_LINE'      , name = "multi_line",       nick = "multi-line",       value = "7"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE', name = "multi_selectable", nick = "multi-selectable", value = "8"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_ORIENTATION'     , name = "orientation",      nick = "orientation",      value = "9"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER'     , name = "placeholder",      nick = "placeholder",      value = "10"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_READ_ONLY'       , name = "read_only",        nick = "read-only",        value = "11"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_REQUIRED'        , name = "required",         nick = "required",         value = "12"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION', name = "role_description", nick = "role-description", value = "13"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_SORT'            , name = "sort",             nick = "sort",             value = "14"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_VALUE_MAX'       , name = "value_max",        nick = "value-max",        value = "15"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_VALUE_MIN'       , name = "value_min",        nick = "value-min",        value = "16"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_VALUE_NOW'       , name = "value_now",        nick = "value-now",        value = "17"}, 
        { macro = 'GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT'      , name = "value_text",       nick = "value-text",       value = "18"}, 
    },
    GtkAccessibleRelation = {
        { macro = 'GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT', name = "active_descendant", nick = "active-descendant", value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_COL_COUNT'        , name = "col_count",         nick = "col-count",         value = "1"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_COL_INDEX'        , name = "col_index",         nick = "col-index",         value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT'   , name = "col_index_text",    nick = "col-index-text",    value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_COL_SPAN'         , name = "col_span",          nick = "col-span",          value = "4"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_CONTROLLED_BY'    , name = "controlled_by",     nick = "controlled-by",     value = "20"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_CONTROLS'         , name = "controls",          nick = "controls",          value = "5"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_DESCRIBED_BY'     , name = "described_by",      nick = "described-by",      value = "6"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_DESCRIPTION_FOR'  , name = "description_for",   nick = "description-for",   value = "19"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_DETAILS'          , name = "details",           nick = "details",           value = "7"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_DETAILS_FOR'      , name = "details_for",       nick = "details-for",       value = "21"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE'    , name = "error_message",     nick = "error-message",     value = "8"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE_FOR', name = "error_message_for", nick = "error-message-for", value = "22"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_FLOW_FROM'        , name = "flow_from",         nick = "flow-from",         value = "23"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_FLOW_TO'          , name = "flow_to",           nick = "flow-to",           value = "9"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_LABEL_FOR'        , name = "label_for",         nick = "label-for",         value = "18"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_LABELLED_BY'      , name = "labelled_by",       nick = "labelled-by",       value = "10"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_OWNS'             , name = "owns",              nick = "owns",              value = "11"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_POS_IN_SET'       , name = "pos_in_set",        nick = "pos-in-set",        value = "12"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_ROW_COUNT'        , name = "row_count",         nick = "row-count",         value = "13"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_ROW_INDEX'        , name = "row_index",         nick = "row-index",         value = "14"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT'   , name = "row_index_text",    nick = "row-index-text",    value = "15"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_ROW_SPAN'         , name = "row_span",          nick = "row-span",          value = "16"}, 
        { macro = 'GTK_ACCESSIBLE_RELATION_SET_SIZE'         , name = "set_size",          nick = "set-size",          value = "17"}, 
    },
    GtkAccessibleRole = {
        { macro = 'GTK_ACCESSIBLE_ROLE_ALERT'             , name = "alert",              nick = "alert",              value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_ALERT_DIALOG'      , name = "alert_dialog",       nick = "alert-dialog",       value = "1"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_APPLICATION'       , name = "application",        nick = "application",        value = "79"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_ARTICLE'           , name = "article",            nick = "article",            value = "82"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_BANNER'            , name = "banner",             nick = "banner",             value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE'       , name = "block_quote",        nick = "block-quote",        value = "81"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_BUTTON'            , name = "button",             nick = "button",             value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_CAPTION'           , name = "caption",            nick = "caption",            value = "4"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_CELL'              , name = "cell",               nick = "cell",               value = "5"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_CHECKBOX'          , name = "checkbox",           nick = "checkbox",           value = "6"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_COLUMN_HEADER'     , name = "column_header",      nick = "column-header",      value = "7"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_COMBO_BOX'         , name = "combo_box",          nick = "combo-box",          value = "8"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_COMMAND'           , name = "command",            nick = "command",            value = "9"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_COMMENT'           , name = "comment",            nick = "comment",            value = "83"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_COMPOSITE'         , name = "composite",          nick = "composite",          value = "10"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_DIALOG'            , name = "dialog",             nick = "dialog",             value = "11"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_DOCUMENT'          , name = "document",           nick = "document",           value = "12"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_FEED'              , name = "feed",               nick = "feed",               value = "13"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_FORM'              , name = "form",               nick = "form",               value = "14"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_GENERIC'           , name = "generic",            nick = "generic",            value = "15"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_GRID'              , name = "grid",               nick = "grid",               value = "16"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_GRID_CELL'         , name = "grid_cell",          nick = "grid-cell",          value = "17"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_GROUP'             , name = "group",              nick = "group",              value = "18"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_HEADING'           , name = "heading",            nick = "heading",            value = "19"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_IMG'               , name = "img",                nick = "img",                value = "20"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_INPUT'             , name = "input",              nick = "input",              value = "21"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LABEL'             , name = "label",              nick = "label",              value = "22"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LANDMARK'          , name = "landmark",           nick = "landmark",           value = "23"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LEGEND'            , name = "legend",             nick = "legend",             value = "24"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LINK'              , name = "link",               nick = "link",               value = "25"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LIST'              , name = "list",               nick = "list",               value = "26"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LIST_BOX'          , name = "list_box",           nick = "list-box",           value = "27"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LIST_ITEM'         , name = "list_item",          nick = "list-item",          value = "28"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_LOG'               , name = "log",                nick = "log",                value = "29"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MAIN'              , name = "main",               nick = "main",               value = "30"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MARQUEE'           , name = "marquee",            nick = "marquee",            value = "31"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MATH'              , name = "math",               nick = "math",               value = "32"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MENU'              , name = "menu",               nick = "menu",               value = "34"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MENU_BAR'          , name = "menu_bar",           nick = "menu-bar",           value = "35"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MENU_ITEM'         , name = "menu_item",          nick = "menu-item",          value = "36"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX', name = "menu_item_checkbox", nick = "menu-item-checkbox", value = "37"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO'   , name = "menu_item_radio",    nick = "menu-item-radio",    value = "38"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_METER'             , name = "meter",              nick = "meter",              value = "33"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_NAVIGATION'        , name = "navigation",         nick = "navigation",         value = "39"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_NONE'              , name = "none",               nick = "none",               value = "40"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_NOTE'              , name = "note",               nick = "note",               value = "41"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_OPTION'            , name = "option",             nick = "option",             value = "42"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_PARAGRAPH'         , name = "paragraph",          nick = "paragraph",          value = "80"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_PRESENTATION'      , name = "presentation",       nick = "presentation",       value = "43"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_PROGRESS_BAR'      , name = "progress_bar",       nick = "progress-bar",       value = "44"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_RADIO'             , name = "radio",              nick = "radio",              value = "45"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_RADIO_GROUP'       , name = "radio_group",        nick = "radio-group",        value = "46"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_RANGE'             , name = "range",              nick = "range",              value = "47"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_REGION'            , name = "region",             nick = "region",             value = "48"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_ROW'               , name = "row",                nick = "row",                value = "49"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_ROW_GROUP'         , name = "row_group",          nick = "row-group",          value = "50"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_ROW_HEADER'        , name = "row_header",         nick = "row-header",         value = "51"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SCROLLBAR'         , name = "scrollbar",          nick = "scrollbar",          value = "52"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SEARCH'            , name = "search",             nick = "search",             value = "53"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SEARCH_BOX'        , name = "search_box",         nick = "search-box",         value = "54"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SECTION'           , name = "section",            nick = "section",            value = "55"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SECTION_HEAD'      , name = "section_head",       nick = "section-head",       value = "56"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SELECT'            , name = "select",             nick = "select",             value = "57"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SEPARATOR'         , name = "separator",          nick = "separator",          value = "58"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SLIDER'            , name = "slider",             nick = "slider",             value = "59"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SPIN_BUTTON'       , name = "spin_button",        nick = "spin-button",        value = "60"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_STATUS'            , name = "status",             nick = "status",             value = "61"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_STRUCTURE'         , name = "structure",          nick = "structure",          value = "62"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_SWITCH'            , name = "switch",             nick = "switch",             value = "63"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TAB'               , name = "tab",                nick = "tab",                value = "64"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TAB_LIST'          , name = "tab_list",           nick = "tab-list",           value = "66"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TAB_PANEL'         , name = "tab_panel",          nick = "tab-panel",          value = "67"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TABLE'             , name = "table",              nick = "table",              value = "65"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TERMINAL'          , name = "terminal",           nick = "terminal",           value = "84"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TEXT_BOX'          , name = "text_box",           nick = "text-box",           value = "68"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TIME'              , name = "time",               nick = "time",               value = "69"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TIMER'             , name = "timer",              nick = "timer",              value = "70"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON'     , name = "toggle_button",      nick = "toggle-button",      value = "78"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TOOLBAR'           , name = "toolbar",            nick = "toolbar",            value = "71"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TOOLTIP'           , name = "tooltip",            nick = "tooltip",            value = "72"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TREE'              , name = "tree",               nick = "tree",               value = "73"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TREE_GRID'         , name = "tree_grid",          nick = "tree-grid",          value = "74"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_TREE_ITEM'         , name = "tree_item",          nick = "tree-item",          value = "75"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_WIDGET'            , name = "widget",             nick = "widget",             value = "76"}, 
        { macro = 'GTK_ACCESSIBLE_ROLE_WINDOW'            , name = "window",             nick = "window",             value = "77"}, 
    },
    GtkAccessibleSort = {
        { macro = 'GTK_ACCESSIBLE_SORT_ASCENDING' , name = "ascending",  nick = "ascending",  value = "1"}, 
        { macro = 'GTK_ACCESSIBLE_SORT_DESCENDING', name = "descending", nick = "descending", value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_SORT_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_SORT_OTHER'     , name = "other",      nick = "other",      value = "3"}, 
    },
    GtkAccessibleState = {
        { macro = 'GTK_ACCESSIBLE_STATE_BUSY'    , name = "busy",     nick = "busy",     value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_CHECKED' , name = "checked",  nick = "checked",  value = "1"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_DISABLED', name = "disabled", nick = "disabled", value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_EXPANDED', name = "expanded", nick = "expanded", value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_HIDDEN'  , name = "hidden",   nick = "hidden",   value = "4"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_INVALID' , name = "invalid",  nick = "invalid",  value = "5"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_PRESSED' , name = "pressed",  nick = "pressed",  value = "6"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_SELECTED', name = "selected", nick = "selected", value = "7"}, 
        { macro = 'GTK_ACCESSIBLE_STATE_VISITED' , name = "visited",  nick = "visited",  value = "8"}, 
    },
    GtkAccessibleTextContentChange = {
        { macro = 'GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT', name = "insert", nick = "insert", value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE', name = "remove", nick = "remove", value = "1"}, 
    },
    GtkAccessibleTextGranularity = {
        { macro = 'GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER', name = "character", nick = "character", value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE'     , name = "line",      nick = "line",      value = "3"}, 
        { macro = 'GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH', name = "paragraph", nick = "paragraph", value = "4"}, 
        { macro = 'GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE' , name = "sentence",  nick = "sentence",  value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD'     , name = "word",      nick = "word",      value = "1"}, 
    },
    GtkAccessibleTristate = {
        { macro = 'GTK_ACCESSIBLE_TRISTATE_FALSE', name = "false", nick = "false", value = "0"}, 
        { macro = 'GTK_ACCESSIBLE_TRISTATE_MIXED', name = "mixed", nick = "mixed", value = "2"}, 
        { macro = 'GTK_ACCESSIBLE_TRISTATE_TRUE' , name = "true",  nick = "true",  value = "1"}, 
    },
    GtkAlign = {
        { macro = 'GTK_ALIGN_BASELINE'       , name = "baseline",        nick = "baseline",        value = "4"}, 
        { macro = 'GTK_ALIGN_BASELINE_CENTER', name = "baseline_center", nick = "baseline-center", value = "5"}, 
        { macro = 'GTK_ALIGN_BASELINE_FILL'  , name = "baseline_fill",   nick = "baseline-fill",   value = "4"}, 
        { macro = 'GTK_ALIGN_CENTER'         , name = "center",          nick = "center",          value = "3"}, 
        { macro = 'GTK_ALIGN_END'            , name = "end",             nick = "end",             value = "2"}, 
        { macro = 'GTK_ALIGN_FILL'           , name = "fill",            nick = "fill",            value = "0"}, 
        { macro = 'GTK_ALIGN_START'          , name = "start",           nick = "start",           value = "1"}, 
    },
    GtkArrowType = {
        { macro = 'GTK_ARROW_DOWN' , name = "down",  nick = "down",  value = "1"}, 
        { macro = 'GTK_ARROW_LEFT' , name = "left",  nick = "left",  value = "2"}, 
        { macro = 'GTK_ARROW_NONE' , name = "none",  nick = "none",  value = "4"}, 
        { macro = 'GTK_ARROW_RIGHT', name = "right", nick = "right", value = "3"}, 
        { macro = 'GTK_ARROW_UP'   , name = "up",    nick = "up",    value = "0"}, 
    },
    GtkAssistantPageType = {
        { macro = 'GTK_ASSISTANT_PAGE_CONFIRM' , name = "confirm",  nick = "confirm",  value = "2"}, 
        { macro = 'GTK_ASSISTANT_PAGE_CONTENT' , name = "content",  nick = "content",  value = "0"}, 
        { macro = 'GTK_ASSISTANT_PAGE_CUSTOM'  , name = "custom",   nick = "custom",   value = "5"}, 
        { macro = 'GTK_ASSISTANT_PAGE_INTRO'   , name = "intro",    nick = "intro",    value = "1"}, 
        { macro = 'GTK_ASSISTANT_PAGE_PROGRESS', name = "progress", nick = "progress", value = "4"}, 
        { macro = 'GTK_ASSISTANT_PAGE_SUMMARY' , name = "summary",  nick = "summary",  value = "3"}, 
    },
    GtkBaselinePosition = {
        { macro = 'GTK_BASELINE_POSITION_BOTTOM', name = "bottom", nick = "bottom", value = "2"}, 
        { macro = 'GTK_BASELINE_POSITION_CENTER', name = "center", nick = "center", value = "1"}, 
        { macro = 'GTK_BASELINE_POSITION_TOP'   , name = "top",    nick = "top",    value = "0"}, 
    },
    GtkBorderStyle = {
        { macro = 'GTK_BORDER_STYLE_DASHED', name = "dashed", nick = "dashed", value = "6"}, 
        { macro = 'GTK_BORDER_STYLE_DOTTED', name = "dotted", nick = "dotted", value = "5"}, 
        { macro = 'GTK_BORDER_STYLE_DOUBLE', name = "double", nick = "double", value = "7"}, 
        { macro = 'GTK_BORDER_STYLE_GROOVE', name = "groove", nick = "groove", value = "8"}, 
        { macro = 'GTK_BORDER_STYLE_HIDDEN', name = "hidden", nick = "hidden", value = "1"}, 
        { macro = 'GTK_BORDER_STYLE_INSET' , name = "inset",  nick = "inset",  value = "3"}, 
        { macro = 'GTK_BORDER_STYLE_NONE'  , name = "none",   nick = "none",   value = "0"}, 
        { macro = 'GTK_BORDER_STYLE_OUTSET', name = "outset", nick = "outset", value = "4"}, 
        { macro = 'GTK_BORDER_STYLE_RIDGE' , name = "ridge",  nick = "ridge",  value = "9"}, 
        { macro = 'GTK_BORDER_STYLE_SOLID' , name = "solid",  nick = "solid",  value = "2"}, 
    },
    GtkBuilderError = {
        { macro = 'GTK_BUILDER_ERROR_DUPLICATE_ID'          , name = "duplicate_id",           nick = "duplicate-id",           value = "8"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_ATTRIBUTE'     , name = "invalid_attribute",      nick = "invalid-attribute",      value = "3"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_FUNCTION'      , name = "invalid_function",       nick = "invalid-function",       value = "14"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_ID'            , name = "invalid_id",             nick = "invalid-id",             value = "13"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_PROPERTY'      , name = "invalid_property",       nick = "invalid-property",       value = "11"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_SIGNAL'        , name = "invalid_signal",         nick = "invalid-signal",         value = "12"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_TAG'           , name = "invalid_tag",            nick = "invalid-tag",            value = "4"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION' , name = "invalid_type_function",  nick = "invalid-type-function",  value = "0"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_VALUE'         , name = "invalid_value",          nick = "invalid-value",          value = "6"}, 
        { macro = 'GTK_BUILDER_ERROR_MISSING_ATTRIBUTE'     , name = "missing_attribute",      nick = "missing-attribute",      value = "2"}, 
        { macro = 'GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE', name = "missing_property_value", nick = "missing-property-value", value = "5"}, 
        { macro = 'GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED'   , name = "object_type_refused",    nick = "object-type-refused",    value = "9"}, 
        { macro = 'GTK_BUILDER_ERROR_TEMPLATE_MISMATCH'     , name = "template_mismatch",      nick = "template-mismatch",      value = "10"}, 
        { macro = 'GTK_BUILDER_ERROR_UNHANDLED_TAG'         , name = "unhandled_tag",          nick = "unhandled-tag",          value = "1"}, 
        { macro = 'GTK_BUILDER_ERROR_VERSION_MISMATCH'      , name = "version_mismatch",       nick = "version-mismatch",       value = "7"}, 
    },
    GtkButtonsType = {
        { macro = 'GTK_BUTTONS_CANCEL'   , name = "cancel",    nick = "cancel",    value = "3"}, 
        { macro = 'GTK_BUTTONS_CLOSE'    , name = "close",     nick = "close",     value = "2"}, 
        { macro = 'GTK_BUTTONS_NONE'     , name = "none",      nick = "none",      value = "0"}, 
        { macro = 'GTK_BUTTONS_OK'       , name = "ok",        nick = "ok",        value = "1"}, 
        { macro = 'GTK_BUTTONS_OK_CANCEL', name = "ok_cancel", nick = "ok-cancel", value = "5"}, 
        { macro = 'GTK_BUTTONS_YES_NO'   , name = "yes_no",    nick = "yes-no",    value = "4"}, 
    },
    GtkCellRendererAccelMode = {
        { macro = 'GTK_CELL_RENDERER_ACCEL_MODE_GTK'  , name = "gtk",   nick = "gtk",   value = "0"}, 
        { macro = 'GTK_CELL_RENDERER_ACCEL_MODE_OTHER', name = "other", nick = "other", value = "1"}, 
    },
    GtkCellRendererMode = {
        { macro = 'GTK_CELL_RENDERER_MODE_ACTIVATABLE', name = "activatable", nick = "activatable", value = "1"}, 
        { macro = 'GTK_CELL_RENDERER_MODE_EDITABLE'   , name = "editable",    nick = "editable",    value = "2"}, 
        { macro = 'GTK_CELL_RENDERER_MODE_INERT'      , name = "inert",       nick = "inert",       value = "0"}, 
    },
    GtkCollation = {
        { macro = 'GTK_COLLATION_FILENAME', name = "filename", nick = "filename", value = "2"}, 
        { macro = 'GTK_COLLATION_NONE'    , name = "none",     nick = "none",     value = "0"}, 
        { macro = 'GTK_COLLATION_UNICODE' , name = "unicode",  nick = "unicode",  value = "1"}, 
    },
    GtkConstraintAttribute = {
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_BASELINE', name = "baseline", nick = "baseline", value = "11"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_BOTTOM'  , name = "bottom",   nick = "bottom",   value = "4"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_CENTER_X', name = "center_x", nick = "center-x", value = "9"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y', name = "center_y", nick = "center-y", value = "10"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_END'     , name = "end",      nick = "end",      value = "6"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_HEIGHT'  , name = "height",   nick = "height",   value = "8"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_LEFT'    , name = "left",     nick = "left",     value = "1"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_NONE'    , name = "none",     nick = "none",     value = "0"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_RIGHT'   , name = "right",    nick = "right",    value = "2"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_START'   , name = "start",    nick = "start",    value = "5"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_TOP'     , name = "top",      nick = "top",      value = "3"}, 
        { macro = 'GTK_CONSTRAINT_ATTRIBUTE_WIDTH'   , name = "width",    nick = "width",    value = "7"}, 
    },
    GtkConstraintRelation = {
        { macro = 'GTK_CONSTRAINT_RELATION_EQ', name = "eq", nick = "eq", value = "0"}, 
        { macro = 'GTK_CONSTRAINT_RELATION_GE', name = "ge", nick = "ge", value = "1"}, 
        { macro = 'GTK_CONSTRAINT_RELATION_LE', name = "le", nick = "le", value = "-1"}, 
    },
    GtkConstraintStrength = {
        { macro = 'GTK_CONSTRAINT_STRENGTH_MEDIUM'  , name = "medium",   nick = "medium",   value = "1000"}, 
        { macro = 'GTK_CONSTRAINT_STRENGTH_REQUIRED', name = "required", nick = "required", value = "1001001000"}, 
        { macro = 'GTK_CONSTRAINT_STRENGTH_STRONG'  , name = "strong",   nick = "strong",   value = "1000000000"}, 
        { macro = 'GTK_CONSTRAINT_STRENGTH_WEAK'    , name = "weak",     nick = "weak",     value = "1"}, 
    },
    GtkConstraintVflParserError = {
        { macro = 'GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE', name = "attribute", nick = "attribute", value = "1"}, 
        { macro = 'GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC'   , name = "metric",    nick = "metric",    value = "3"}, 
        { macro = 'GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY' , name = "priority",  nick = "priority",  value = "4"}, 
        { macro = 'GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION' , name = "relation",  nick = "relation",  value = "5"}, 
        { macro = 'GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL'   , name = "symbol",    nick = "symbol",    value = "0"}, 
        { macro = 'GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW'     , name = "view",      nick = "view",      value = "2"}, 
    },
    GtkContentFit = {
        { macro = 'GTK_CONTENT_FIT_CONTAIN'   , name = "contain",    nick = "contain",    value = "1"}, 
        { macro = 'GTK_CONTENT_FIT_COVER'     , name = "cover",      nick = "cover",      value = "2"}, 
        { macro = 'GTK_CONTENT_FIT_FILL'      , name = "fill",       nick = "fill",       value = "0"}, 
        { macro = 'GTK_CONTENT_FIT_SCALE_DOWN', name = "scale_down", nick = "scale-down", value = "3"}, 
    },
    GtkCornerType = {
        { macro = 'GTK_CORNER_BOTTOM_LEFT' , name = "bottom_left",  nick = "bottom-left",  value = "1"}, 
        { macro = 'GTK_CORNER_BOTTOM_RIGHT', name = "bottom_right", nick = "bottom-right", value = "3"}, 
        { macro = 'GTK_CORNER_TOP_LEFT'    , name = "top_left",     nick = "top-left",     value = "0"}, 
        { macro = 'GTK_CORNER_TOP_RIGHT'   , name = "top_right",    nick = "top-right",    value = "2"}, 
    },
    GtkCssParserError = {
        { macro = 'GTK_CSS_PARSER_ERROR_FAILED'       , name = "failed",        nick = "failed",        value = "0"}, 
        { macro = 'GTK_CSS_PARSER_ERROR_IMPORT'       , name = "import",        nick = "import",        value = "2"}, 
        { macro = 'GTK_CSS_PARSER_ERROR_NAME'         , name = "name",          nick = "name",          value = "3"}, 
        { macro = 'GTK_CSS_PARSER_ERROR_SYNTAX'       , name = "syntax",        nick = "syntax",        value = "1"}, 
        { macro = 'GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE', name = "unknown_value", nick = "unknown_value", value = "4"}, 
    },
    GtkCssParserWarning = {
        { macro = 'GTK_CSS_PARSER_WARNING_DEPRECATED'   , name = "deprecated",    nick = "deprecated",    value = "0"}, 
        { macro = 'GTK_CSS_PARSER_WARNING_SYNTAX'       , name = "syntax",        nick = "syntax",        value = "1"}, 
        { macro = 'GTK_CSS_PARSER_WARNING_UNIMPLEMENTED', name = "unimplemented", nick = "unimplemented", value = "2"}, 
    },
    GtkDeleteType = {
        { macro = 'GTK_DELETE_CHARS'            , name = "chars",             nick = "chars",             value = "0"}, 
        { macro = 'GTK_DELETE_DISPLAY_LINE_ENDS', name = "display_line_ends", nick = "display-line-ends", value = "4"}, 
        { macro = 'GTK_DELETE_DISPLAY_LINES'    , name = "display_lines",     nick = "display-lines",     value = "3"}, 
        { macro = 'GTK_DELETE_PARAGRAPH_ENDS'   , name = "paragraph_ends",    nick = "paragraph-ends",    value = "5"}, 
        { macro = 'GTK_DELETE_PARAGRAPHS'       , name = "paragraphs",        nick = "paragraphs",        value = "6"}, 
        { macro = 'GTK_DELETE_WHITESPACE'       , name = "whitespace",        nick = "whitespace",        value = "7"}, 
        { macro = 'GTK_DELETE_WORD_ENDS'        , name = "word_ends",         nick = "word-ends",         value = "1"}, 
        { macro = 'GTK_DELETE_WORDS'            , name = "words",             nick = "words",             value = "2"}, 
    },
    GtkDialogError = {
        { macro = 'GTK_DIALOG_ERROR_CANCELLED', name = "cancelled", nick = "cancelled", value = "1"}, 
        { macro = 'GTK_DIALOG_ERROR_DISMISSED', name = "dismissed", nick = "dismissed", value = "2"}, 
        { macro = 'GTK_DIALOG_ERROR_FAILED'   , name = "failed",    nick = "failed",    value = "0"}, 
    },
    GtkDirectionType = {
        { macro = 'GTK_DIR_DOWN'        , name = "down",         nick = "down",         value = "3"}, 
        { macro = 'GTK_DIR_LEFT'        , name = "left",         nick = "left",         value = "4"}, 
        { macro = 'GTK_DIR_RIGHT'       , name = "right",        nick = "right",        value = "5"}, 
        { macro = 'GTK_DIR_TAB_BACKWARD', name = "tab_backward", nick = "tab-backward", value = "1"}, 
        { macro = 'GTK_DIR_TAB_FORWARD' , name = "tab_forward",  nick = "tab-forward",  value = "0"}, 
        { macro = 'GTK_DIR_UP'          , name = "up",           nick = "up",           value = "2"}, 
    },
    GtkEditableProperties = {
        { macro = 'GTK_EDITABLE_NUM_PROPERTIES'      , name = "num_properties",       nick = "num-properties",       value = "8"}, 
        { macro = 'GTK_EDITABLE_PROP_CURSOR_POSITION', name = "prop_cursor_position", nick = "prop-cursor-position", value = "1"}, 
        { macro = 'GTK_EDITABLE_PROP_EDITABLE'       , name = "prop_editable",        nick = "prop-editable",        value = "3"}, 
        { macro = 'GTK_EDITABLE_PROP_ENABLE_UNDO'    , name = "prop_enable_undo",     nick = "prop-enable-undo",     value = "7"}, 
        { macro = 'GTK_EDITABLE_PROP_MAX_WIDTH_CHARS', name = "prop_max_width_chars", nick = "prop-max-width-chars", value = "5"}, 
        { macro = 'GTK_EDITABLE_PROP_SELECTION_BOUND', name = "prop_selection_bound", nick = "prop-selection-bound", value = "2"}, 
        { macro = 'GTK_EDITABLE_PROP_TEXT'           , name = "prop_text",            nick = "prop-text",            value = "0"}, 
        { macro = 'GTK_EDITABLE_PROP_WIDTH_CHARS'    , name = "prop_width_chars",     nick = "prop-width-chars",     value = "4"}, 
        { macro = 'GTK_EDITABLE_PROP_XALIGN'         , name = "prop_xalign",          nick = "prop-xalign",          value = "6"}, 
    },
    GtkEntryIconPosition = {
        { macro = 'GTK_ENTRY_ICON_PRIMARY'  , name = "primary",   nick = "primary",   value = "0"}, 
        { macro = 'GTK_ENTRY_ICON_SECONDARY', name = "secondary", nick = "secondary", value = "1"}, 
    },
    GtkEventSequenceState = {
        { macro = 'GTK_EVENT_SEQUENCE_CLAIMED', name = "claimed", nick = "claimed", value = "1"}, 
        { macro = 'GTK_EVENT_SEQUENCE_DENIED' , name = "denied",  nick = "denied",  value = "2"}, 
        { macro = 'GTK_EVENT_SEQUENCE_NONE'   , name = "none",    nick = "none",    value = "0"}, 
    },
    GtkFileChooserAction = {
        { macro = 'GTK_FILE_CHOOSER_ACTION_OPEN'         , name = "open",          nick = "open",          value = "0"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_SAVE'         , name = "save",          nick = "save",          value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER', name = "select_folder", nick = "select-folder", value = "2"}, 
    },
    GtkFileChooserError = {
        { macro = 'GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS'     , name = "already_exists",      nick = "already-exists",      value = "2"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_BAD_FILENAME'       , name = "bad_filename",        nick = "bad-filename",        value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME', name = "incomplete_hostname", nick = "incomplete-hostname", value = "3"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_NONEXISTENT'        , name = "nonexistent",         nick = "nonexistent",         value = "0"}, 
    },
    GtkFilterChange = {
        { macro = 'GTK_FILTER_CHANGE_DIFFERENT'  , name = "different",   nick = "different",   value = "0"}, 
        { macro = 'GTK_FILTER_CHANGE_LESS_STRICT', name = "less_strict", nick = "less-strict", value = "1"}, 
        { macro = 'GTK_FILTER_CHANGE_MORE_STRICT', name = "more_strict", nick = "more-strict", value = "2"}, 
    },
    GtkFilterMatch = {
        { macro = 'GTK_FILTER_MATCH_ALL' , name = "all",  nick = "all",  value = "2"}, 
        { macro = 'GTK_FILTER_MATCH_NONE', name = "none", nick = "none", value = "1"}, 
        { macro = 'GTK_FILTER_MATCH_SOME', name = "some", nick = "some", value = "0"}, 
    },
    GtkFontLevel = {
        { macro = 'GTK_FONT_LEVEL_FACE'    , name = "face",     nick = "face",     value = "1"}, 
        { macro = 'GTK_FONT_LEVEL_FAMILY'  , name = "family",   nick = "family",   value = "0"}, 
        { macro = 'GTK_FONT_LEVEL_FEATURES', name = "features", nick = "features", value = "3"}, 
        { macro = 'GTK_FONT_LEVEL_FONT'    , name = "font",     nick = "font",     value = "2"}, 
    },
    GtkFontRendering = {
        { macro = 'GTK_FONT_RENDERING_AUTOMATIC', name = "automatic", nick = "automatic", value = "0"}, 
        { macro = 'GTK_FONT_RENDERING_MANUAL'   , name = "manual",    nick = "manual",    value = "1"}, 
    },
    GtkGraphicsOffloadEnabled = {
        { macro = 'GTK_GRAPHICS_OFFLOAD_DISABLED', name = "disabled", nick = "disabled", value = "1"}, 
        { macro = 'GTK_GRAPHICS_OFFLOAD_ENABLED' , name = "enabled",  nick = "enabled",  value = "0"}, 
    },
    GtkIconSize = {
        { macro = 'GTK_ICON_SIZE_INHERIT', name = "inherit", nick = "inherit", value = "0"}, 
        { macro = 'GTK_ICON_SIZE_LARGE'  , name = "large",   nick = "large",   value = "2"}, 
        { macro = 'GTK_ICON_SIZE_NORMAL' , name = "normal",  nick = "normal",  value = "1"}, 
    },
    GtkIconThemeError = {
        { macro = 'GTK_ICON_THEME_FAILED'   , name = "failed",    nick = "failed",    value = "1"}, 
        { macro = 'GTK_ICON_THEME_NOT_FOUND', name = "not_found", nick = "not-found", value = "0"}, 
    },
    GtkIconViewDropPosition = {
        { macro = 'GTK_ICON_VIEW_DROP_ABOVE', name = "drop_above", nick = "drop-above", value = "4"}, 
        { macro = 'GTK_ICON_VIEW_DROP_BELOW', name = "drop_below", nick = "drop-below", value = "5"}, 
        { macro = 'GTK_ICON_VIEW_DROP_INTO' , name = "drop_into",  nick = "drop-into",  value = "1"}, 
        { macro = 'GTK_ICON_VIEW_DROP_LEFT' , name = "drop_left",  nick = "drop-left",  value = "2"}, 
        { macro = 'GTK_ICON_VIEW_DROP_RIGHT', name = "drop_right", nick = "drop-right", value = "3"}, 
        { macro = 'GTK_ICON_VIEW_NO_DROP'   , name = "no_drop",    nick = "no-drop",    value = "0"}, 
    },
    GtkImageType = {
        { macro = 'GTK_IMAGE_EMPTY'    , name = "empty",     nick = "empty",     value = "0"}, 
        { macro = 'GTK_IMAGE_GICON'    , name = "gicon",     nick = "gicon",     value = "2"}, 
        { macro = 'GTK_IMAGE_ICON_NAME', name = "icon_name", nick = "icon-name", value = "1"}, 
        { macro = 'GTK_IMAGE_PAINTABLE', name = "paintable", nick = "paintable", value = "3"}, 
    },
    GtkInputPurpose = {
        { macro = 'GTK_INPUT_PURPOSE_ALPHA'    , name = "alpha",     nick = "alpha",     value = "1"}, 
        { macro = 'GTK_INPUT_PURPOSE_DIGITS'   , name = "digits",    nick = "digits",    value = "2"}, 
        { macro = 'GTK_INPUT_PURPOSE_EMAIL'    , name = "email",     nick = "email",     value = "6"}, 
        { macro = 'GTK_INPUT_PURPOSE_FREE_FORM', name = "free_form", nick = "free-form", value = "0"}, 
        { macro = 'GTK_INPUT_PURPOSE_NAME'     , name = "name",      nick = "name",      value = "7"}, 
        { macro = 'GTK_INPUT_PURPOSE_NUMBER'   , name = "number",    nick = "number",    value = "3"}, 
        { macro = 'GTK_INPUT_PURPOSE_PASSWORD' , name = "password",  nick = "password",  value = "8"}, 
        { macro = 'GTK_INPUT_PURPOSE_PHONE'    , name = "phone",     nick = "phone",     value = "4"}, 
        { macro = 'GTK_INPUT_PURPOSE_PIN'      , name = "pin",       nick = "pin",       value = "9"}, 
        { macro = 'GTK_INPUT_PURPOSE_TERMINAL' , name = "terminal",  nick = "terminal",  value = "10"}, 
        { macro = 'GTK_INPUT_PURPOSE_URL'      , name = "url",       nick = "url",       value = "5"}, 
    },
    GtkInscriptionOverflow = {
        { macro = 'GTK_INSCRIPTION_OVERFLOW_CLIP'            , name = "clip",             nick = "clip",             value = "0"}, 
        { macro = 'GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_END'   , name = "ellipsize_end",    nick = "ellipsize-end",    value = "3"}, 
        { macro = 'GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_MIDDLE', name = "ellipsize_middle", nick = "ellipsize-middle", value = "2"}, 
        { macro = 'GTK_INSCRIPTION_OVERFLOW_ELLIPSIZE_START' , name = "ellipsize_start",  nick = "ellipsize-start",  value = "1"}, 
    },
    GtkJustification = {
        { macro = 'GTK_JUSTIFY_CENTER', name = "center", nick = "center", value = "2"}, 
        { macro = 'GTK_JUSTIFY_FILL'  , name = "fill",   nick = "fill",   value = "3"}, 
        { macro = 'GTK_JUSTIFY_LEFT'  , name = "left",   nick = "left",   value = "0"}, 
        { macro = 'GTK_JUSTIFY_RIGHT' , name = "right",  nick = "right",  value = "1"}, 
    },
    GtkLevelBarMode = {
        { macro = 'GTK_LEVEL_BAR_MODE_CONTINUOUS', name = "continuous", nick = "continuous", value = "0"}, 
        { macro = 'GTK_LEVEL_BAR_MODE_DISCRETE'  , name = "discrete",   nick = "discrete",   value = "1"}, 
    },
    GtkLicense = {
        { macro = 'GTK_LICENSE_0BSD'         , name = "0bsd",          nick = "0bsd",          value = "18"}, 
        { macro = 'GTK_LICENSE_AGPL_3_0'     , name = "agpl_3_0",      nick = "agpl-3-0",      value = "13"}, 
        { macro = 'GTK_LICENSE_AGPL_3_0_ONLY', name = "agpl_3_0_only", nick = "agpl-3-0-only", value = "14"}, 
        { macro = 'GTK_LICENSE_APACHE_2_0'   , name = "apache_2_0",    nick = "apache-2-0",    value = "16"}, 
        { macro = 'GTK_LICENSE_ARTISTIC'     , name = "artistic",      nick = "artistic",      value = "8"}, 
        { macro = 'GTK_LICENSE_BSD'          , name = "bsd",           nick = "bsd",           value = "6"}, 
        { macro = 'GTK_LICENSE_BSD_3'        , name = "bsd_3",         nick = "bsd-3",         value = "15"}, 
        { macro = 'GTK_LICENSE_CUSTOM'       , name = "custom",        nick = "custom",        value = "1"}, 
        { macro = 'GTK_LICENSE_GPL_2_0'      , name = "gpl_2_0",       nick = "gpl-2-0",       value = "2"}, 
        { macro = 'GTK_LICENSE_GPL_2_0_ONLY' , name = "gpl_2_0_only",  nick = "gpl-2-0-only",  value = "9"}, 
        { macro = 'GTK_LICENSE_GPL_3_0'      , name = "gpl_3_0",       nick = "gpl-3-0",       value = "3"}, 
        { macro = 'GTK_LICENSE_GPL_3_0_ONLY' , name = "gpl_3_0_only",  nick = "gpl-3-0-only",  value = "10"}, 
        { macro = 'GTK_LICENSE_LGPL_2_1'     , name = "lgpl_2_1",      nick = "lgpl-2-1",      value = "4"}, 
        { macro = 'GTK_LICENSE_LGPL_2_1_ONLY', name = "lgpl_2_1_only", nick = "lgpl-2-1-only", value = "11"}, 
        { macro = 'GTK_LICENSE_LGPL_3_0'     , name = "lgpl_3_0",      nick = "lgpl-3-0",      value = "5"}, 
        { macro = 'GTK_LICENSE_LGPL_3_0_ONLY', name = "lgpl_3_0_only", nick = "lgpl-3-0-only", value = "12"}, 
        { macro = 'GTK_LICENSE_MIT_X11'      , name = "mit_x11",       nick = "mit-x11",       value = "7"}, 
        { macro = 'GTK_LICENSE_MPL_2_0'      , name = "mpl_2_0",       nick = "mpl-2-0",       value = "17"}, 
        { macro = 'GTK_LICENSE_UNKNOWN'      , name = "unknown",       nick = "unknown",       value = "0"}, 
    },
    GtkListTabBehavior = {
        { macro = 'GTK_LIST_TAB_ALL' , name = "all",  nick = "all",  value = "0"}, 
        { macro = 'GTK_LIST_TAB_CELL', name = "cell", nick = "cell", value = "2"}, 
        { macro = 'GTK_LIST_TAB_ITEM', name = "item", nick = "item", value = "1"}, 
    },
    GtkMessageType = {
        { macro = 'GTK_MESSAGE_ERROR'   , name = "error",    nick = "error",    value = "3"}, 
        { macro = 'GTK_MESSAGE_INFO'    , name = "info",     nick = "info",     value = "0"}, 
        { macro = 'GTK_MESSAGE_OTHER'   , name = "other",    nick = "other",    value = "4"}, 
        { macro = 'GTK_MESSAGE_QUESTION', name = "question", nick = "question", value = "2"}, 
        { macro = 'GTK_MESSAGE_WARNING' , name = "warning",  nick = "warning",  value = "1"}, 
    },
    GtkMovementStep = {
        { macro = 'GTK_MOVEMENT_BUFFER_ENDS'      , name = "buffer_ends",       nick = "buffer-ends",       value = "8"}, 
        { macro = 'GTK_MOVEMENT_DISPLAY_LINE_ENDS', name = "display_line_ends", nick = "display-line-ends", value = "4"}, 
        { macro = 'GTK_MOVEMENT_DISPLAY_LINES'    , name = "display_lines",     nick = "display-lines",     value = "3"}, 
        { macro = 'GTK_MOVEMENT_HORIZONTAL_PAGES' , name = "horizontal_pages",  nick = "horizontal-pages",  value = "9"}, 
        { macro = 'GTK_MOVEMENT_LOGICAL_POSITIONS', name = "logical_positions", nick = "logical-positions", value = "0"}, 
        { macro = 'GTK_MOVEMENT_PAGES'            , name = "pages",             nick = "pages",             value = "7"}, 
        { macro = 'GTK_MOVEMENT_PARAGRAPH_ENDS'   , name = "paragraph_ends",    nick = "paragraph-ends",    value = "6"}, 
        { macro = 'GTK_MOVEMENT_PARAGRAPHS'       , name = "paragraphs",        nick = "paragraphs",        value = "5"}, 
        { macro = 'GTK_MOVEMENT_VISUAL_POSITIONS' , name = "visual_positions",  nick = "visual-positions",  value = "1"}, 
        { macro = 'GTK_MOVEMENT_WORDS'            , name = "words",             nick = "words",             value = "2"}, 
    },
    GtkNaturalWrapMode = {
        { macro = 'GTK_NATURAL_WRAP_INHERIT', name = "inherit", nick = "inherit", value = "0"}, 
        { macro = 'GTK_NATURAL_WRAP_NONE'   , name = "none",    nick = "none",    value = "1"}, 
        { macro = 'GTK_NATURAL_WRAP_WORD'   , name = "word",    nick = "word",    value = "2"}, 
    },
    GtkNotebookTab = {
        { macro = 'GTK_NOTEBOOK_TAB_FIRST', name = "first", nick = "first", value = "0"}, 
        { macro = 'GTK_NOTEBOOK_TAB_LAST' , name = "last",  nick = "last",  value = "1"}, 
    },
    GtkNumberUpLayout = {
        { macro = 'GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT', name = "btlr", nick = "btlr", value = "6"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT', name = "btrl", nick = "btrl", value = "7"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP', name = "lrbt", nick = "lrbt", value = "1"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM', name = "lrtb", nick = "lrtb", value = "0"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP', name = "rlbt", nick = "rlbt", value = "3"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM', name = "rltb", nick = "rltb", value = "2"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT', name = "tblr", nick = "tblr", value = "4"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT', name = "tbrl", nick = "tbrl", value = "5"}, 
    },
    GtkOrdering = {
        { macro = 'GTK_ORDERING_EQUAL'  , name = "equal",   nick = "equal",   value = "0"}, 
        { macro = 'GTK_ORDERING_LARGER' , name = "larger",  nick = "larger",  value = "1"}, 
        { macro = 'GTK_ORDERING_SMALLER', name = "smaller", nick = "smaller", value = "-1"}, 
    },
    GtkOrientation = {
        { macro = 'GTK_ORIENTATION_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "0"}, 
        { macro = 'GTK_ORIENTATION_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "1"}, 
    },
    GtkOverflow = {
        { macro = 'GTK_OVERFLOW_HIDDEN' , name = "hidden",  nick = "hidden",  value = "1"}, 
        { macro = 'GTK_OVERFLOW_VISIBLE', name = "visible", nick = "visible", value = "0"}, 
    },
    GtkPackType = {
        { macro = 'GTK_PACK_END'  , name = "end",   nick = "end",   value = "1"}, 
        { macro = 'GTK_PACK_START', name = "start", nick = "start", value = "0"}, 
    },
    GtkPadActionType = {
        { macro = 'GTK_PAD_ACTION_BUTTON', name = "button", nick = "button", value = "0"}, 
        { macro = 'GTK_PAD_ACTION_RING'  , name = "ring",   nick = "ring",   value = "1"}, 
        { macro = 'GTK_PAD_ACTION_STRIP' , name = "strip",  nick = "strip",  value = "2"}, 
    },
    GtkPageOrientation = {
        { macro = 'GTK_PAGE_ORIENTATION_LANDSCAPE'        , name = "landscape",         nick = "landscape",         value = "1"}, 
        { macro = 'GTK_PAGE_ORIENTATION_PORTRAIT'         , name = "portrait",          nick = "portrait",          value = "0"}, 
        { macro = 'GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE', name = "reverse_landscape", nick = "reverse-landscape", value = "3"}, 
        { macro = 'GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT' , name = "reverse_portrait",  nick = "reverse-portrait",  value = "2"}, 
    },
    GtkPageSet = {
        { macro = 'GTK_PAGE_SET_ALL' , name = "all",  nick = "all",  value = "0"}, 
        { macro = 'GTK_PAGE_SET_EVEN', name = "even", nick = "even", value = "1"}, 
        { macro = 'GTK_PAGE_SET_ODD' , name = "odd",  nick = "odd",  value = "2"}, 
    },
    GtkPanDirection = {
        { macro = 'GTK_PAN_DIRECTION_DOWN' , name = "down",  nick = "down",  value = "3"}, 
        { macro = 'GTK_PAN_DIRECTION_LEFT' , name = "left",  nick = "left",  value = "0"}, 
        { macro = 'GTK_PAN_DIRECTION_RIGHT', name = "right", nick = "right", value = "1"}, 
        { macro = 'GTK_PAN_DIRECTION_UP'   , name = "up",    nick = "up",    value = "2"}, 
    },
    GtkPolicyType = {
        { macro = 'GTK_POLICY_ALWAYS'   , name = "always",    nick = "always",    value = "0"}, 
        { macro = 'GTK_POLICY_AUTOMATIC', name = "automatic", nick = "automatic", value = "1"}, 
        { macro = 'GTK_POLICY_EXTERNAL' , name = "external",  nick = "external",  value = "3"}, 
        { macro = 'GTK_POLICY_NEVER'    , name = "never",     nick = "never",     value = "2"}, 
    },
    GtkPositionType = {
        { macro = 'GTK_POS_BOTTOM', name = "bottom", nick = "bottom", value = "3"}, 
        { macro = 'GTK_POS_LEFT'  , name = "left",   nick = "left",   value = "0"}, 
        { macro = 'GTK_POS_RIGHT' , name = "right",  nick = "right",  value = "1"}, 
        { macro = 'GTK_POS_TOP'   , name = "top",    nick = "top",    value = "2"}, 
    },
    GtkPrintDuplex = {
        { macro = 'GTK_PRINT_DUPLEX_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_PRINT_DUPLEX_SIMPLEX'   , name = "simplex",    nick = "simplex",    value = "0"}, 
        { macro = 'GTK_PRINT_DUPLEX_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkPrintError = {
        { macro = 'GTK_PRINT_ERROR_GENERAL'       , name = "general",        nick = "general",        value = "0"}, 
        { macro = 'GTK_PRINT_ERROR_INTERNAL_ERROR', name = "internal_error", nick = "internal-error", value = "1"}, 
        { macro = 'GTK_PRINT_ERROR_INVALID_FILE'  , name = "invalid_file",   nick = "invalid-file",   value = "3"}, 
        { macro = 'GTK_PRINT_ERROR_NOMEM'         , name = "nomem",          nick = "nomem",          value = "2"}, 
    },
    GtkPrintOperationAction = {
        { macro = 'GTK_PRINT_OPERATION_ACTION_EXPORT'      , name = "export",       nick = "export",       value = "3"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PREVIEW'     , name = "preview",      nick = "preview",      value = "2"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PRINT'       , name = "print",        nick = "print",        value = "1"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG', name = "print_dialog", nick = "print-dialog", value = "0"}, 
    },
    GtkPrintOperationResult = {
        { macro = 'GTK_PRINT_OPERATION_RESULT_APPLY'      , name = "apply",       nick = "apply",       value = "1"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_CANCEL'     , name = "cancel",      nick = "cancel",      value = "2"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_ERROR'      , name = "error",       nick = "error",       value = "0"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_IN_PROGRESS', name = "in_progress", nick = "in-progress", value = "3"}, 
    },
    GtkPrintPages = {
        { macro = 'GTK_PRINT_PAGES_ALL'      , name = "all",       nick = "all",       value = "0"}, 
        { macro = 'GTK_PRINT_PAGES_CURRENT'  , name = "current",   nick = "current",   value = "1"}, 
        { macro = 'GTK_PRINT_PAGES_RANGES'   , name = "ranges",    nick = "ranges",    value = "2"}, 
        { macro = 'GTK_PRINT_PAGES_SELECTION', name = "selection", nick = "selection", value = "3"}, 
    },
    GtkPrintQuality = {
        { macro = 'GTK_PRINT_QUALITY_DRAFT' , name = "draft",  nick = "draft",  value = "3"}, 
        { macro = 'GTK_PRINT_QUALITY_HIGH'  , name = "high",   nick = "high",   value = "2"}, 
        { macro = 'GTK_PRINT_QUALITY_LOW'   , name = "low",    nick = "low",    value = "0"}, 
        { macro = 'GTK_PRINT_QUALITY_NORMAL', name = "normal", nick = "normal", value = "1"}, 
    },
    GtkPrintStatus = {
        { macro = 'GTK_PRINT_STATUS_FINISHED'        , name = "finished",         nick = "finished",         value = "7"}, 
        { macro = 'GTK_PRINT_STATUS_FINISHED_ABORTED', name = "finished_aborted", nick = "finished-aborted", value = "8"}, 
        { macro = 'GTK_PRINT_STATUS_GENERATING_DATA' , name = "generating_data",  nick = "generating-data",  value = "2"}, 
        { macro = 'GTK_PRINT_STATUS_INITIAL'         , name = "initial",          nick = "initial",          value = "0"}, 
        { macro = 'GTK_PRINT_STATUS_PENDING'         , name = "pending",          nick = "pending",          value = "4"}, 
        { macro = 'GTK_PRINT_STATUS_PENDING_ISSUE'   , name = "pending_issue",    nick = "pending-issue",    value = "5"}, 
        { macro = 'GTK_PRINT_STATUS_PREPARING'       , name = "preparing",        nick = "preparing",        value = "1"}, 
        { macro = 'GTK_PRINT_STATUS_PRINTING'        , name = "printing",         nick = "printing",         value = "6"}, 
        { macro = 'GTK_PRINT_STATUS_SENDING_DATA'    , name = "sending_data",     nick = "sending-data",     value = "3"}, 
    },
    GtkPropagationLimit = {
        { macro = 'GTK_LIMIT_NONE'       , name = "none",        nick = "none",        value = "0"}, 
        { macro = 'GTK_LIMIT_SAME_NATIVE', name = "same_native", nick = "same-native", value = "1"}, 
    },
    GtkPropagationPhase = {
        { macro = 'GTK_PHASE_BUBBLE' , name = "bubble",  nick = "bubble",  value = "2"}, 
        { macro = 'GTK_PHASE_CAPTURE', name = "capture", nick = "capture", value = "1"}, 
        { macro = 'GTK_PHASE_NONE'   , name = "none",    nick = "none",    value = "0"}, 
        { macro = 'GTK_PHASE_TARGET' , name = "target",  nick = "target",  value = "3"}, 
    },
    GtkRecentManagerError = {
        { macro = 'GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING', name = "invalid_encoding", nick = "invalid-encoding", value = "2"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_INVALID_URI'     , name = "invalid_uri",      nick = "invalid-uri",      value = "1"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_NOT_FOUND'       , name = "not_found",        nick = "not-found",        value = "0"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED'  , name = "not_registered",   nick = "not-registered",   value = "3"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_READ'            , name = "read",             nick = "read",             value = "4"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_UNKNOWN'         , name = "unknown",          nick = "unknown",          value = "6"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_WRITE'           , name = "write",            nick = "write",            value = "5"}, 
    },
    GtkResponseType = {
        { macro = 'GTK_RESPONSE_ACCEPT'      , name = "accept",       nick = "accept",       value = "-3"}, 
        { macro = 'GTK_RESPONSE_APPLY'       , name = "apply",        nick = "apply",        value = "-10"}, 
        { macro = 'GTK_RESPONSE_CANCEL'      , name = "cancel",       nick = "cancel",       value = "-6"}, 
        { macro = 'GTK_RESPONSE_CLOSE'       , name = "close",        nick = "close",        value = "-7"}, 
        { macro = 'GTK_RESPONSE_DELETE_EVENT', name = "delete_event", nick = "delete-event", value = "-4"}, 
        { macro = 'GTK_RESPONSE_HELP'        , name = "help",         nick = "help",         value = "-11"}, 
        { macro = 'GTK_RESPONSE_NO'          , name = "no",           nick = "no",           value = "-9"}, 
        { macro = 'GTK_RESPONSE_NONE'        , name = "none",         nick = "none",         value = "-1"}, 
        { macro = 'GTK_RESPONSE_OK'          , name = "ok",           nick = "ok",           value = "-5"}, 
        { macro = 'GTK_RESPONSE_REJECT'      , name = "reject",       nick = "reject",       value = "-2"}, 
        { macro = 'GTK_RESPONSE_YES'         , name = "yes",          nick = "yes",          value = "-8"}, 
    },
    GtkRevealerTransitionType = {
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_CROSSFADE'  , name = "crossfade",   nick = "crossfade",   value = "1"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_NONE'       , name = "none",        nick = "none",        value = "0"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN' , name = "slide_down",  nick = "slide-down",  value = "5"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT' , name = "slide_left",  nick = "slide-left",  value = "3"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT', name = "slide_right", nick = "slide-right", value = "2"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP'   , name = "slide_up",    nick = "slide-up",    value = "4"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN' , name = "swing_down",  nick = "swing-down",  value = "9"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT' , name = "swing_left",  nick = "swing-left",  value = "7"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT', name = "swing_right", nick = "swing-right", value = "6"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SWING_UP'   , name = "swing_up",    nick = "swing-up",    value = "8"}, 
    },
    GtkScrollStep = {
        { macro = 'GTK_SCROLL_ENDS'            , name = "ends",             nick = "ends",             value = "2"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_ENDS' , name = "horizontal_ends",  nick = "horizontal-ends",  value = "5"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_PAGES', name = "horizontal_pages", nick = "horizontal-pages", value = "4"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_STEPS', name = "horizontal_steps", nick = "horizontal-steps", value = "3"}, 
        { macro = 'GTK_SCROLL_PAGES'           , name = "pages",            nick = "pages",            value = "1"}, 
        { macro = 'GTK_SCROLL_STEPS'           , name = "steps",            nick = "steps",            value = "0"}, 
    },
    GtkScrollType = {
        { macro = 'GTK_SCROLL_END'          , name = "end",           nick = "end",           value = "15"}, 
        { macro = 'GTK_SCROLL_JUMP'         , name = "jump",          nick = "jump",          value = "1"}, 
        { macro = 'GTK_SCROLL_NONE'         , name = "none",          nick = "none",          value = "0"}, 
        { macro = 'GTK_SCROLL_PAGE_BACKWARD', name = "page_backward", nick = "page-backward", value = "4"}, 
        { macro = 'GTK_SCROLL_PAGE_DOWN'    , name = "page_down",     nick = "page-down",     value = "9"}, 
        { macro = 'GTK_SCROLL_PAGE_FORWARD' , name = "page_forward",  nick = "page-forward",  value = "5"}, 
        { macro = 'GTK_SCROLL_PAGE_LEFT'    , name = "page_left",     nick = "page-left",     value = "12"}, 
        { macro = 'GTK_SCROLL_PAGE_RIGHT'   , name = "page_right",    nick = "page-right",    value = "13"}, 
        { macro = 'GTK_SCROLL_PAGE_UP'      , name = "page_up",       nick = "page-up",       value = "8"}, 
        { macro = 'GTK_SCROLL_START'        , name = "start",         nick = "start",         value = "14"}, 
        { macro = 'GTK_SCROLL_STEP_BACKWARD', name = "step_backward", nick = "step-backward", value = "2"}, 
        { macro = 'GTK_SCROLL_STEP_DOWN'    , name = "step_down",     nick = "step-down",     value = "7"}, 
        { macro = 'GTK_SCROLL_STEP_FORWARD' , name = "step_forward",  nick = "step-forward",  value = "3"}, 
        { macro = 'GTK_SCROLL_STEP_LEFT'    , name = "step_left",     nick = "step-left",     value = "10"}, 
        { macro = 'GTK_SCROLL_STEP_RIGHT'   , name = "step_right",    nick = "step-right",    value = "11"}, 
        { macro = 'GTK_SCROLL_STEP_UP'      , name = "step_up",       nick = "step-up",       value = "6"}, 
    },
    GtkScrollablePolicy = {
        { macro = 'GTK_SCROLL_MINIMUM', name = "minimum", nick = "minimum", value = "0"}, 
        { macro = 'GTK_SCROLL_NATURAL', name = "natural", nick = "natural", value = "1"}, 
    },
    GtkSelectionMode = {
        { macro = 'GTK_SELECTION_BROWSE'  , name = "browse",   nick = "browse",   value = "2"}, 
        { macro = 'GTK_SELECTION_MULTIPLE', name = "multiple", nick = "multiple", value = "3"}, 
        { macro = 'GTK_SELECTION_NONE'    , name = "none",     nick = "none",     value = "0"}, 
        { macro = 'GTK_SELECTION_SINGLE'  , name = "single",   nick = "single",   value = "1"}, 
    },
    GtkSensitivityType = {
        { macro = 'GTK_SENSITIVITY_AUTO', name = "auto", nick = "auto", value = "0"}, 
        { macro = 'GTK_SENSITIVITY_OFF' , name = "off",  nick = "off",  value = "2"}, 
        { macro = 'GTK_SENSITIVITY_ON'  , name = "on",   nick = "on",   value = "1"}, 
    },
    GtkShortcutScope = {
        { macro = 'GTK_SHORTCUT_SCOPE_GLOBAL' , name = "global",  nick = "global",  value = "2"}, 
        { macro = 'GTK_SHORTCUT_SCOPE_LOCAL'  , name = "local",   nick = "local",   value = "0"}, 
        { macro = 'GTK_SHORTCUT_SCOPE_MANAGED', name = "managed", nick = "managed", value = "1"}, 
    },
    GtkShortcutType = {
        { macro = 'GTK_SHORTCUT_ACCELERATOR'                    , name = "accelerator",                     nick = "accelerator",                     value = "0"}, 
        { macro = 'GTK_SHORTCUT_GESTURE'                        , name = "gesture",                         nick = "gesture",                         value = "7"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_PINCH'                  , name = "gesture_pinch",                   nick = "gesture-pinch",                   value = "1"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE'       , name = "gesture_rotate_clockwise",        nick = "gesture-rotate-clockwise",        value = "3"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE', name = "gesture_rotate_counterclockwise", nick = "gesture-rotate-counterclockwise", value = "4"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_STRETCH'                , name = "gesture_stretch",                 nick = "gesture-stretch",                 value = "2"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_SWIPE_LEFT'             , name = "gesture_swipe_left",              nick = "gesture-swipe-left",              value = "8"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_SWIPE_RIGHT'            , name = "gesture_swipe_right",             nick = "gesture-swipe-right",             value = "9"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT'  , name = "gesture_two_finger_swipe_left",   nick = "gesture-two-finger-swipe-left",   value = "5"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT' , name = "gesture_two_finger_swipe_right",  nick = "gesture-two-finger-swipe-right",  value = "6"}, 
    },
    GtkSizeGroupMode = {
        { macro = 'GTK_SIZE_GROUP_BOTH'      , name = "both",       nick = "both",       value = "3"}, 
        { macro = 'GTK_SIZE_GROUP_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_SIZE_GROUP_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_SIZE_GROUP_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkSizeRequestMode = {
        { macro = 'GTK_SIZE_REQUEST_CONSTANT_SIZE'   , name = "constant_size",    nick = "constant-size",    value = "2"}, 
        { macro = 'GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH', name = "height_for_width", nick = "height-for-width", value = "0"}, 
        { macro = 'GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT', name = "width_for_height", nick = "width-for-height", value = "1"}, 
    },
    GtkSortType = {
        { macro = 'GTK_SORT_ASCENDING' , name = "ascending",  nick = "ascending",  value = "0"}, 
        { macro = 'GTK_SORT_DESCENDING', name = "descending", nick = "descending", value = "1"}, 
    },
    GtkSorterChange = {
        { macro = 'GTK_SORTER_CHANGE_DIFFERENT'  , name = "different",   nick = "different",   value = "0"}, 
        { macro = 'GTK_SORTER_CHANGE_INVERTED'   , name = "inverted",    nick = "inverted",    value = "1"}, 
        { macro = 'GTK_SORTER_CHANGE_LESS_STRICT', name = "less_strict", nick = "less-strict", value = "2"}, 
        { macro = 'GTK_SORTER_CHANGE_MORE_STRICT', name = "more_strict", nick = "more-strict", value = "3"}, 
    },
    GtkSorterOrder = {
        { macro = 'GTK_SORTER_ORDER_NONE'   , name = "none",    nick = "none",    value = "1"}, 
        { macro = 'GTK_SORTER_ORDER_PARTIAL', name = "partial", nick = "partial", value = "0"}, 
        { macro = 'GTK_SORTER_ORDER_TOTAL'  , name = "total",   nick = "total",   value = "2"}, 
    },
    GtkSpinButtonUpdatePolicy = {
        { macro = 'GTK_UPDATE_ALWAYS'  , name = "always",   nick = "always",   value = "0"}, 
        { macro = 'GTK_UPDATE_IF_VALID', name = "if_valid", nick = "if-valid", value = "1"}, 
    },
    GtkSpinType = {
        { macro = 'GTK_SPIN_END'          , name = "end",           nick = "end",           value = "5"}, 
        { macro = 'GTK_SPIN_HOME'         , name = "home",          nick = "home",          value = "4"}, 
        { macro = 'GTK_SPIN_PAGE_BACKWARD', name = "page_backward", nick = "page-backward", value = "3"}, 
        { macro = 'GTK_SPIN_PAGE_FORWARD' , name = "page_forward",  nick = "page-forward",  value = "2"}, 
        { macro = 'GTK_SPIN_STEP_BACKWARD', name = "step_backward", nick = "step-backward", value = "1"}, 
        { macro = 'GTK_SPIN_STEP_FORWARD' , name = "step_forward",  nick = "step-forward",  value = "0"}, 
        { macro = 'GTK_SPIN_USER_DEFINED' , name = "user_defined",  nick = "user-defined",  value = "6"}, 
    },
    GtkStackTransitionType = {
        { macro = 'GTK_STACK_TRANSITION_TYPE_CROSSFADE'        , name = "crossfade",         nick = "crossfade",         value = "1"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_NONE'             , name = "none",              nick = "none",              value = "0"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_DOWN'        , name = "over_down",         nick = "over-down",         value = "9"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP'     , name = "over_down_up",      nick = "over-down-up",      value = "17"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_LEFT'        , name = "over_left",         nick = "over-left",         value = "10"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT'  , name = "over_left_right",   nick = "over-left-right",   value = "18"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_RIGHT'       , name = "over_right",        nick = "over-right",        value = "11"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT'  , name = "over_right_left",   nick = "over-right-left",   value = "19"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_UP'          , name = "over_up",           nick = "over-up",           value = "8"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN'     , name = "over_up_down",      nick = "over-up-down",      value = "16"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT'      , name = "rotate_left",       nick = "rotate-left",       value = "20"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT', name = "rotate_left_right", nick = "rotate-left-right", value = "22"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT'     , name = "rotate_right",      nick = "rotate-right",      value = "21"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN'       , name = "slide_down",        nick = "slide-down",        value = "5"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT'       , name = "slide_left",        nick = "slide-left",        value = "3"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT' , name = "slide_left_right",  nick = "slide-left-right",  value = "6"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT'      , name = "slide_right",       nick = "slide-right",       value = "2"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_UP'         , name = "slide_up",          nick = "slide-up",          value = "4"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN'    , name = "slide_up_down",     nick = "slide-up-down",     value = "7"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_DOWN'       , name = "under_down",        nick = "under-down",        value = "13"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_LEFT'       , name = "under_left",        nick = "under-left",        value = "14"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT'      , name = "under_right",       nick = "under-right",       value = "15"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_UP'         , name = "under_up",          nick = "under-up",          value = "12"}, 
    },
    GtkStringFilterMatchMode = {
        { macro = 'GTK_STRING_FILTER_MATCH_MODE_EXACT'    , name = "exact",     nick = "exact",     value = "0"}, 
        { macro = 'GTK_STRING_FILTER_MATCH_MODE_PREFIX'   , name = "prefix",    nick = "prefix",    value = "2"}, 
        { macro = 'GTK_STRING_FILTER_MATCH_MODE_SUBSTRING', name = "substring", nick = "substring", value = "1"}, 
    },
    GtkSymbolicColor = {
        { macro = 'GTK_SYMBOLIC_COLOR_ERROR'     , name = "error",      nick = "error",      value = "1"}, 
        { macro = 'GTK_SYMBOLIC_COLOR_FOREGROUND', name = "foreground", nick = "foreground", value = "0"}, 
        { macro = 'GTK_SYMBOLIC_COLOR_SUCCESS'   , name = "success",    nick = "success",    value = "3"}, 
        { macro = 'GTK_SYMBOLIC_COLOR_WARNING'   , name = "warning",    nick = "warning",    value = "2"}, 
    },
    GtkSystemSetting = {
        { macro = 'GTK_SYSTEM_SETTING_DISPLAY'    , name = "display",     nick = "display",     value = "3"}, 
        { macro = 'GTK_SYSTEM_SETTING_DPI'        , name = "dpi",         nick = "dpi",         value = "0"}, 
        { macro = 'GTK_SYSTEM_SETTING_FONT_CONFIG', name = "font_config", nick = "font-config", value = "2"}, 
        { macro = 'GTK_SYSTEM_SETTING_FONT_NAME'  , name = "font_name",   nick = "font-name",   value = "1"}, 
        { macro = 'GTK_SYSTEM_SETTING_ICON_THEME' , name = "icon_theme",  nick = "icon-theme",  value = "4"}, 
    },
    GtkTextDirection = {
        { macro = 'GTK_TEXT_DIR_LTR' , name = "ltr",  nick = "ltr",  value = "1"}, 
        { macro = 'GTK_TEXT_DIR_NONE', name = "none", nick = "none", value = "0"}, 
        { macro = 'GTK_TEXT_DIR_RTL' , name = "rtl",  nick = "rtl",  value = "2"}, 
    },
    GtkTextExtendSelection = {
        { macro = 'GTK_TEXT_EXTEND_SELECTION_LINE', name = "line", nick = "line", value = "1"}, 
        { macro = 'GTK_TEXT_EXTEND_SELECTION_WORD', name = "word", nick = "word", value = "0"}, 
    },
    GtkTextViewLayer = {
        { macro = 'GTK_TEXT_VIEW_LAYER_ABOVE_TEXT', name = "above_text", nick = "above-text", value = "1"}, 
        { macro = 'GTK_TEXT_VIEW_LAYER_BELOW_TEXT', name = "below_text", nick = "below-text", value = "0"}, 
    },
    GtkTextWindowType = {
        { macro = 'GTK_TEXT_WINDOW_BOTTOM', name = "bottom", nick = "bottom", value = "6"}, 
        { macro = 'GTK_TEXT_WINDOW_LEFT'  , name = "left",   nick = "left",   value = "3"}, 
        { macro = 'GTK_TEXT_WINDOW_RIGHT' , name = "right",  nick = "right",  value = "4"}, 
        { macro = 'GTK_TEXT_WINDOW_TEXT'  , name = "text",   nick = "text",   value = "2"}, 
        { macro = 'GTK_TEXT_WINDOW_TOP'   , name = "top",    nick = "top",    value = "5"}, 
        { macro = 'GTK_TEXT_WINDOW_WIDGET', name = "widget", nick = "widget", value = "1"}, 
    },
    GtkTreeViewColumnSizing = {
        { macro = 'GTK_TREE_VIEW_COLUMN_AUTOSIZE' , name = "autosize",  nick = "autosize",  value = "1"}, 
        { macro = 'GTK_TREE_VIEW_COLUMN_FIXED'    , name = "fixed",     nick = "fixed",     value = "2"}, 
        { macro = 'GTK_TREE_VIEW_COLUMN_GROW_ONLY', name = "grow_only", nick = "grow-only", value = "0"}, 
    },
    GtkTreeViewDropPosition = {
        { macro = 'GTK_TREE_VIEW_DROP_AFTER'         , name = "after",          nick = "after",          value = "1"}, 
        { macro = 'GTK_TREE_VIEW_DROP_BEFORE'        , name = "before",         nick = "before",         value = "0"}, 
        { macro = 'GTK_TREE_VIEW_DROP_INTO_OR_AFTER' , name = "into_or_after",  nick = "into-or-after",  value = "3"}, 
        { macro = 'GTK_TREE_VIEW_DROP_INTO_OR_BEFORE', name = "into_or_before", nick = "into-or-before", value = "2"}, 
    },
    GtkTreeViewGridLines = {
        { macro = 'GTK_TREE_VIEW_GRID_LINES_BOTH'      , name = "both",       nick = "both",       value = "3"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkUnit = {
        { macro = 'GTK_UNIT_INCH'  , name = "inch",   nick = "inch",   value = "2"}, 
        { macro = 'GTK_UNIT_MM'    , name = "mm",     nick = "mm",     value = "3"}, 
        { macro = 'GTK_UNIT_NONE'  , name = "none",   nick = "none",   value = "0"}, 
        { macro = 'GTK_UNIT_POINTS', name = "points", nick = "points", value = "1"}, 
    },
    GtkWrapMode = {
        { macro = 'GTK_WRAP_CHAR'     , name = "char",      nick = "char",      value = "1"}, 
        { macro = 'GTK_WRAP_NONE'     , name = "none",      nick = "none",      value = "0"}, 
        { macro = 'GTK_WRAP_WORD'     , name = "word",      nick = "word",      value = "2"}, 
        { macro = 'GTK_WRAP_WORD_CHAR', name = "word_char", nick = "word-char", value = "3"}, 
    },
}); end;
----  [Gtk Enumerates] End ... 


---------------- gtk4.18.patch.lua，控件大致按照字母顺序（除个别存在前置依赖关系）

----------------==  GtkAccessible
----------------==  GtkAccessibleRange
----------------==  GtkAccessibleText
----------------==  GtkActionable
----------------==  GtkAppChooser
----------------==  GtkBuildable
----------------==  GtkBuilderScope
----------------==  GtkCellEditable
----------------==  GtkCellLayout
----------------==  GtkColorChooser
----------------==  GtkConstraintTarget
----------------==  GtkEditable
----------------==  GtkFileChooser
----------------==  GtkFontChooser
----------------==  GtkNative
----------------==  GtkOrientable
----------------==  GtkPrintOperationPreview
----------------==  GtkRoot
----------------==  GtkScrollable
----------------==  GtkSectionModel
----------------==  GtkSelectionModel
----------------==  GtkShortcutManager
----------------==  GtkStyleProvider
----------------==  GtkSymbolicPaintable
----------------==  GtkTreeDragDest
----------------==  GtkTreeDragSource
----------------==  GtkTreeModel
----------------==  GtkTreeSortable
----------------==  GtkATContext
----------------==  GtkAdjustment
----------------==  GtkAlertDialog
----------------==  GtkApplication
----------------==  GtkAssistantPage
----------------==  GtkBookmarkList
----------------==  GtkBuilder
----------------==  GtkBuilderCScope
----------------==  GtkCellArea
----------------==  GtkCellAreaContext
----------------==  GtkCellRenderer
----------------==  GtkColorDialog
----------------==  GtkColumnViewColumn
----------------==  GtkColumnViewRow
----------------==  GtkConstraint
----------------==  GtkConstraintGuide
----------------==  GtkCssProvider
----------------==  GtkDirectoryList
----------------==  GtkEntryBuffer
----------------==  GtkEntryCompletion
----------------==  GtkEventController
----------------==  GtkExpression
----------------==  GtkFileDialog
----------------==  GtkFileLauncher
----------------==  GtkFilter
----------------==  GtkFilterListModel
----------------==  GtkFlattenListModel
----------------==  GtkFontDialog
----------------==  GtkIMContext
----------------==  GtkIconPaintable
----------------==  GtkIconTheme
----------------==  GtkLayoutChild
----------------==  GtkLayoutManager
----------------==  GtkListHeader
----------------==  GtkListItem
----------------==  GtkListItemFactory
----------------==  GtkListStore
----------------==  GtkMapListModel
----------------==  GtkMediaStream
----------------==  GtkMountOperation
----------------==  GtkMultiSelection
----------------==  GtkNativeDialog
----------------==  GtkNoSelection
----------------==  GtkNotebookPage
----------------==  GtkPageSetup
----------------==  GtkParamSpecExpression
----------------==  GtkPrintContext
----------------==  GtkPrintDialog
----------------==  GtkPrintJob
----------------==  GtkPrintOperation
----------------==  GtkPrintSettings
----------------==  GtkPrinter
----------------==  GtkRecentManager
----------------==  GtkSelectionFilterModel
----------------==  GtkSettings
----------------==  GtkShortcut
----------------==  GtkShortcutAction
----------------==  GtkShortcutTrigger
----------------==  GtkSingleSelection
----------------==  GtkSizeGroup
----------------==  GtkSliceListModel
----------------==  GtkSnapshot
----------------==  GtkSortListModel
----------------==  GtkSorter
----------------==  GtkStackPage
----------------==  GtkStringList
----------------==  GtkStringObject
----------------==  GtkStyleContext
----------------==  GtkTextBuffer
----------------==  GtkTextChildAnchor
----------------==  GtkTextMark
----------------==  GtkTextTag
----------------==  GtkTextTagTable
----------------==  GtkTooltip
----------------==  GtkTreeListModel
----------------==  GtkTreeListRow
----------------==  GtkTreeModelFilter
----------------==  GtkTreeModelSort
----------------==  GtkTreeSelection
----------------==  GtkTreeStore
----------------==  GtkTreeViewColumn
----------------==  GtkUriLauncher
----------------==  GtkWidget
----------------==  GtkWidgetPaintable
----------------==  GtkWindowGroup
----------------==  GtkActionBar
----------------==  GtkActivateAction
----------------==  GtkAlternativeTrigger
----------------==  GtkAppChooserButton
----------------==  GtkAppChooserWidget
----------------==  GtkAspectFrame
----------------==  GtkBinLayout
----------------==  GtkBoolFilter
----------------==  GtkBox
----------------==  GtkBoxLayout
----------------==  GtkBuilderListItemFactory
----------------==  GtkButton
----------------==  GtkCClosureExpression
----------------==  GtkCalendar
----------------==  GtkCallbackAction
----------------==  GtkCellAreaBox
----------------==  GtkCellRendererPixbuf
----------------==  GtkCellRendererProgress
----------------==  GtkCellRendererSpinner
----------------==  GtkCellRendererText
----------------==  GtkCellRendererToggle
----------------==  GtkCellView
----------------==  GtkCenterBox
----------------==  GtkCenterLayout
----------------==  GtkCheckButton
----------------==  GtkClosureExpression
----------------==  GtkColorButton
----------------==  GtkColorChooserWidget
----------------==  GtkColorDialogButton
----------------==  GtkColumnView
----------------==  GtkColumnViewCell
----------------==  GtkColumnViewSorter
----------------==  GtkComboBox
----------------==  GtkConstantExpression
----------------==  GtkConstraintLayout
----------------==  GtkConstraintLayoutChild
----------------==  GtkCustomFilter
----------------==  GtkCustomLayout
----------------==  GtkCustomSorter
----------------==  GtkDragIcon
----------------==  GtkDrawingArea
----------------==  GtkDropControllerMotion
----------------==  GtkDropDown
----------------==  GtkDropTarget
----------------==  GtkDropTargetAsync
----------------==  GtkEditableLabel
----------------==  GtkEntry
----------------==  GtkEventControllerFocus
----------------==  GtkEventControllerKey
----------------==  GtkEventControllerLegacy
----------------==  GtkEventControllerMotion
----------------==  GtkEventControllerScroll
----------------==  GtkExpander
----------------==  GtkFileChooserNative
----------------==  GtkFileChooserWidget
----------------==  GtkFileFilter
----------------==  GtkFixed
----------------==  GtkFixedLayout
----------------==  GtkFixedLayoutChild
----------------==  GtkFlowBox
----------------==  GtkFlowBoxChild
----------------==  GtkFontButton
----------------==  GtkFontChooserWidget
----------------==  GtkFontDialogButton
----------------==  GtkFrame
----------------==  GtkGLArea
----------------==  GtkGesture
----------------==  GtkGraphicsOffload
----------------==  GtkGrid
----------------==  GtkGridLayout
----------------==  GtkGridLayoutChild
----------------==  GtkHeaderBar
----------------==  GtkIMContextSimple
----------------==  GtkIMMulticontext
----------------==  GtkIconView
----------------==  GtkImage
----------------==  GtkInfoBar
----------------==  GtkInscription
----------------==  GtkKeyvalTrigger
----------------==  GtkLabel
----------------==  GtkLevelBar
----------------==  GtkListBase
----------------==  GtkListBox
----------------==  GtkListBoxRow
----------------==  GtkMediaControls
----------------==  GtkMediaFile
----------------==  GtkMenuButton
----------------==  GtkMnemonicAction
----------------==  GtkMnemonicTrigger
----------------==  GtkMultiFilter
----------------==  GtkMultiSorter
----------------==  GtkNamedAction
----------------==  GtkNeverTrigger
----------------==  GtkNotebook
----------------==  GtkNothingAction
----------------==  GtkNumericSorter
----------------==  GtkObjectExpression
----------------==  GtkOverlay
----------------==  GtkOverlayLayout
----------------==  GtkOverlayLayoutChild
----------------==  GtkPadController
----------------==  GtkPaned
----------------==  GtkPasswordEntry
----------------==  GtkPasswordEntryBuffer
----------------==  GtkPicture
----------------==  GtkPopover
----------------==  GtkPopoverMenuBar
----------------==  GtkProgressBar
----------------==  GtkPropertyExpression
----------------==  GtkRange
----------------==  GtkRevealer
----------------==  GtkScaleButton
----------------==  GtkScrollbar
----------------==  GtkScrolledWindow
----------------==  GtkSearchBar
----------------==  GtkSearchEntry
----------------==  GtkSeparator
----------------==  GtkShortcutController
----------------==  GtkShortcutLabel
----------------==  GtkShortcutsShortcut
----------------==  GtkSignalAction
----------------==  GtkSignalListItemFactory
----------------==  GtkSpinButton
----------------==  GtkSpinner
----------------==  GtkStack
----------------==  GtkStackSidebar
----------------==  GtkStackSwitcher
----------------==  GtkStatusbar
----------------==  GtkStringFilter
----------------==  GtkStringSorter
----------------==  GtkSwitch
----------------==  GtkText
----------------==  GtkTextView
----------------==  GtkTreeExpander
----------------==  GtkTreeListRowSorter
----------------==  GtkTreeView
----------------==  GtkVideo
----------------==  GtkViewport
----------------==  GtkWindow
----------------==  GtkWindowControls
----------------==  GtkWindowHandle
----------------==  GtkAboutDialog
----------------==  GtkAnyFilter
----------------==  GtkApplicationWindow
----------------==  GtkAssistant
----------------==  GtkCellRendererAccel
----------------==  GtkCellRendererCombo
----------------==  GtkCellRendererSpin
----------------==  GtkComboBoxText
----------------==  GtkDialog
----------------==  GtkEmojiChooser
----------------==  GtkEveryFilter
----------------==  GtkGestureRotate
----------------==  GtkGestureSingle
----------------==  GtkGestureZoom
----------------==  GtkGridView
----------------==  GtkLinkButton
----------------==  GtkListView
----------------==  GtkLockButton
----------------==  GtkPopoverMenu
----------------==  GtkScale
----------------==  GtkShortcutsGroup
----------------==  GtkShortcutsSection
----------------==  GtkShortcutsWindow
----------------==  GtkToggleButton
----------------==  GtkVolumeButton
----------------==  GtkAppChooserDialog
----------------==  GtkColorChooserDialog
----------------==  GtkDragSource
----------------==  GtkFileChooserDialog
----------------==  GtkFontChooserDialog
----------------==  GtkGestureClick
----------------==  GtkGestureDrag
----------------==  GtkGestureLongPress
----------------==  GtkGestureStylus
----------------==  GtkGestureSwipe
----------------==  GtkMessageDialog
----------------==  GtkPageSetupUnixDialog
----------------==  GtkPrintUnixDialog
----------------==  GtkGesturePan
